();
100 |
101 | var world = World.That_is_a_barren_wasteland();
102 | world.When_a_cell_dies = location => cell_death_locations.Add(location);
103 | world.When_a_cell_comes_to_life = location => cell_birth_locations.Add(location);
104 |
105 | world.TouchCellAt(Location.At(2, 1));
106 | world.TouchCellAt(Location.At(2, 1));
107 | world.MomentPassed();
108 |
109 | Assert.That(cell_death_locations, Is.EquivalentTo(new Location[] { }), "it should not cause any death events");
110 | Assert.That(cell_birth_locations, Is.EquivalentTo(new Location[] { }), "it should not cause any birth events");
111 | }
112 | }
113 | }
114 |
--------------------------------------------------------------------------------
/Life/Cell_Behaviours.cs:
--------------------------------------------------------------------------------
1 | using NUnit.Framework;
2 |
3 | namespace Life
4 | {
5 | [TestFixture]
6 | public class Cell_Behaviours
7 | {
8 | [Test]
9 | public void When_a_cell_has_no_neighbors_and_a_moment_passes()
10 | {
11 | var cell = Cell.ThatsAlive();
12 |
13 | var cell_died = false;
14 | cell.When_it_dies = () => cell_died = true;
15 | cell.MomentPassed();
16 |
17 | Assert.That(cell_died, "It should die.");
18 | }
19 |
20 | [Test]
21 | public void When_a_cell_has_no_neighbors_and_more_than_one_moment_passes()
22 | {
23 | var cell = Cell.ThatsAlive();
24 |
25 | var died_count = 0;
26 | cell.When_it_dies = () => died_count++;
27 | cell.MomentPassed();
28 | cell.MomentPassed();
29 |
30 | Assert.That(died_count, Is.EqualTo(1), "It should die only once.");
31 | }
32 |
33 | [Test]
34 | public void When_a_cell_has_one_neighbor_and_a_moment_passes()
35 | {
36 | var cell = Cell.ThatsAlive();
37 | cell.NeighborWasBorn();
38 |
39 | var cell_died = false;
40 | cell.When_it_dies = () => cell_died = true;
41 | cell.MomentPassed();
42 |
43 | Assert.That(cell_died, "It should die.");
44 | }
45 |
46 | [Test]
47 | public void When_a_cell_has_two_neighbors_and_a_moment_passes()
48 | {
49 | var cell = Cell.ThatsAliveWithNeighbors(2);
50 |
51 | var cell_died = false;
52 | cell.When_it_dies = () => cell_died = true;
53 | cell.MomentPassed();
54 |
55 | Assert.That(cell_died, Is.False, "It should live on.");
56 | }
57 |
58 | [Test]
59 | public void When_a_dead_cell_has_one_neighbors_and_a_moment_passes()
60 | {
61 | var cell = Cell.ThatsDeadWithNeighbors(1);
62 |
63 | var cell_died = false;
64 | cell.When_it_dies = () => cell_died = true;
65 | cell.MomentPassed();
66 |
67 | Assert.That(cell_died, Is.False, "It should not die when it's already dead.");
68 | }
69 |
70 | [Test]
71 | public void When_a_cell_has_three_neighbors_and_a_moment_passes()
72 | {
73 | var cell = Cell.ThatsAliveWithNeighbors(3);
74 |
75 | var cell_died = false;
76 | cell.When_it_dies = () => cell_died = true;
77 | cell.MomentPassed();
78 |
79 | Assert.That(cell_died, Is.False, "It should live on.");
80 | }
81 |
82 | [Test]
83 | public void When_a_live_cell_has_more_than_three_neighbors_and_a_moment_passes()
84 | {
85 | var cell = Cell.ThatsAliveWithNeighbors(4);
86 |
87 | var cell_died = false;
88 | cell.When_it_dies = () => cell_died = true;
89 | cell.MomentPassed();
90 |
91 | Assert.That(cell_died, "it should die as if from overcrowding.");
92 | }
93 |
94 | [Test]
95 | public void When_a_dead_cell_has_exactly_three_neighbors()
96 | {
97 | var dead_cell = Cell.ThatsDeadWithNeighbors(3);
98 |
99 | var cell_was_born = false;
100 | dead_cell.When_its_born = () => cell_was_born = true;
101 | dead_cell.MomentPassed();
102 |
103 | Assert.That(cell_was_born, "it should come to life");
104 | }
105 |
106 | [Test]
107 | public void When_a_dead_cell_has_exactly_three_neighbors_and_more_than_one_moment_passes()
108 | {
109 | var dead_cell = Cell.ThatsDeadWithNeighbors(3);
110 |
111 | var number_of_times_born = 0;
112 | dead_cell.When_its_born = () => number_of_times_born++;
113 | dead_cell.MomentPassed();
114 | dead_cell.MomentPassed();
115 |
116 | Assert.That(number_of_times_born, Is.EqualTo(1), "it should be born only once.");
117 | }
118 |
119 | [Test]
120 | public void When_a_live_cell_is_notified_that_a_neighbor_died()
121 | {
122 | var cell_died = false;
123 | var cell = Cell.ThatsAliveWithNeighbors(2);
124 | cell.When_it_dies = () => cell_died = true;
125 | cell.NeighborDied();
126 |
127 | cell.MomentPassed();
128 |
129 | Assert.That(cell_died, "it should affect its view of the world.");
130 | }
131 |
132 | [Test]
133 | public void When_a_neighboring_cell_dies_without_knowing_of_any_neighbors()
134 | {
135 | var cell_born = false;
136 | var cell = Cell.ThatsDeadWithNeighbors(0);
137 | cell.When_its_born = () => cell_born = true;
138 | cell.NeighborDied();
139 | cell.NeighborWasBorn();
140 | cell.NeighborWasBorn();
141 | cell.NeighborWasBorn();
142 | cell.MomentPassed();
143 |
144 | Assert.That(cell_born, "it should count neighbors up from zero and not go into negatives.");
145 | }
146 |
147 | [Test]
148 | public void When_the_hand_of_god_touches_a_live_cell()
149 | {
150 | var cell_died = false;
151 | var cell = Cell.ThatsAliveWithNeighbors(0);
152 | cell.When_it_dies = () => cell_died = true;
153 | cell.Touched();
154 |
155 | Assert.That(cell_died, "Touching a live cell should kill it.");
156 | }
157 |
158 | [Test]
159 | public void When_the_hand_of_god_touches_a_dead_cell()
160 | {
161 | var cell_was_born = false;
162 | var cell = Cell.ThatsDeadWithNeighbors(0);
163 | cell.When_its_born = () => cell_was_born = true;
164 | cell.Touched();
165 |
166 | Assert.That(cell_was_born, "Touching a dead cell should bring it back to life.");
167 | }
168 | }
169 | }
170 |
--------------------------------------------------------------------------------
/lib/nunit/NUnitFitTests.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 | NUnit Acceptance Tests
5 |
6 | Developers love self-referential programs! Hence, NUnit has always run all it's
7 | own tests, even those that are not really unit tests.
8 |
Now, beginning with NUnit 2.4, NUnit has top-level tests using Ward Cunningham's
9 | FIT framework. At this time, the tests are pretty rudimentary, but it's a start
10 | and it's a framework for doing more.
11 |
Running the Tests
12 | Open a console or shell window and navigate to the NUnit bin directory, which
13 | contains this file. To run the test under Microsoft .Net, enter the command
14 |
runFile NUnitFitTests.html TestResults.html .
15 | To run it under Mono, enter
16 | mono runFile.exe NUnitFitTests.html TestResults.html .
17 | Note the space and dot at the end of each command. The results of your test
18 | will be in TestResults.html in the same directory.
19 | Platform and CLR Version
20 |
21 |
22 | | NUnit.Fixtures.PlatformInfo |
23 |
24 |
25 | Verify Unit Tests
26 |
27 | Load and run the NUnit unit tests, verifying that the results are as expected.
28 | When these tests are run on different platforms, different numbers of tests may
29 | be skipped, so the values for Skipped and Run tests are informational only.
30 |
31 | The number of tests in each assembly should be constant across all platforms -
32 | any discrepancy usually means that one of the test source files was not
33 | compiled on the platform. There should be no failures and no tests ignored.
34 |
Note:
35 | At the moment, the nunit.extensions.tests assembly is failing because the
36 | fixture doesn't initialize addins in the test domain.
37 |
38 |
39 |
40 | | NUnit.Fixtures.AssemblyRunner |
41 |
42 |
43 | | Assembly |
44 | Tests() |
45 | Run() |
46 | Skipped() |
47 | Ignored() |
48 | Failures() |
49 |
50 |
51 | | nunit.framework.tests.dll |
52 | 397 |
53 | |
54 | |
55 | 0 |
56 | 0 |
57 |
58 |
59 | | nunit.core.tests.dll |
60 | 355 |
61 | |
62 | |
63 | 0 |
64 | 0 |
65 |
66 |
67 | | nunit.util.tests.dll |
68 | 238 |
69 | |
70 | |
71 | 0 |
72 | 0 |
73 |
74 |
75 | | nunit.mocks.tests.dll |
76 | 43 |
77 | |
78 | |
79 | 0 |
80 | 0 |
81 |
82 |
83 | | nunit.extensions.tests.dll |
84 | 5 |
85 | |
86 | |
87 | 0 |
88 | 0 |
89 |
90 |
91 | | nunit-console.tests.dll |
92 | 40 |
93 | |
94 | |
95 | 0 |
96 | 0 |
97 |
98 |
99 | | nunit.uikit.tests.dll |
100 | 34 |
101 | |
102 | |
103 | 0 |
104 | 0 |
105 |
106 |
107 | | nunit-gui.tests.dll |
108 | 15 |
109 | |
110 | |
111 | 0 |
112 | 0 |
113 |
114 |
115 | | nunit.fixtures.tests.dll |
116 | 6 |
117 | |
118 | |
119 | 0 |
120 | 0 |
121 |
122 |
123 | Code Snippet Tests
124 |
125 | These tests create a test assembly from a snippet of code and then load and run
126 | the tests that it contains, verifying that the structure of the loaded tests is
127 | as expected and that the number of tests run, skipped, ignored or failed is
128 | correct.
129 |
130 |
131 |
132 | | NUnit.Fixtures.SnippetRunner |
133 |
134 |
135 | | Code |
136 | Tree() |
137 | Run() |
138 | Skipped() |
139 | Ignored() |
140 | Failures() |
141 |
142 |
143 | public class TestClass
144 | {
145 | }
146 | |
147 | EMPTY |
148 | 0 |
149 | 0 |
150 | 0 |
151 | 0 |
152 |
153 |
154 | using NUnit.Framework;
155 |
156 | [TestFixture]
157 | public class TestClass
158 | {
159 | }
160 | |
161 | TestClass |
162 | 0 |
163 | 0 |
164 | 0 |
165 | 0 |
166 |
167 |
168 | using NUnit.Framework;
169 |
170 | [TestFixture]
171 | public class TestClass
172 | {
173 | [Test]
174 | public void T1() { }
175 | [Test]
176 | public void T2() { }
177 | [Test]
178 | public void T3() { }
179 | }
180 | |
181 | TestClass
182 | >T1
183 | >T2
184 | >T3
185 | |
186 | 3 |
187 | 0 |
188 | 0 |
189 | 0 |
190 |
191 |
192 | using NUnit.Framework;
193 |
194 | [TestFixture]
195 | public class TestClass1
196 | {
197 | [Test]
198 | public void T1() { }
199 | }
200 |
201 | [TestFixture]
202 | public class TestClass2
203 | {
204 | [Test]
205 | public void T2() { }
206 | [Test]
207 | public void T3() { }
208 | }
209 | |
210 | TestClass1
211 | >T1
212 | TestClass2
213 | >T2
214 | >T3
215 | |
216 | 3 |
217 | 0 |
218 | 0 |
219 | 0 |
220 |
221 |
222 | using NUnit.Framework;
223 |
224 | [TestFixture]
225 | public class TestClass
226 | {
227 | [Test]
228 | public void T1() { }
229 | [Test, Ignore]
230 | public void T2() { }
231 | [Test]
232 | public void T3() { }
233 | }
234 | |
235 | TestClass
236 | >T1
237 | >T2
238 | >T3
239 | |
240 | 2 |
241 | 0 |
242 | 1 |
243 | 0 |
244 |
245 |
246 | using NUnit.Framework;
247 |
248 | [TestFixture]
249 | public class TestClass
250 | {
251 | [Test]
252 | public void T1() { }
253 | [Test, Explicit]
254 | public void T2() { }
255 | [Test]
256 | public void T3() { }
257 | }
258 | |
259 | TestClass
260 | >T1
261 | >T2
262 | >T3
263 | |
264 | 2 |
265 | 1 |
266 | 0 |
267 | 0 |
268 |
269 |
270 | Summary Information
271 |
272 |
273 | | fit.Summary |
274 |
275 |
276 |
277 |
278 |
--------------------------------------------------------------------------------
/lib/nunit/Tools/NUnitFitTests.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 | NUnit Acceptance Tests
5 |
6 | Developers love self-referential programs! Hence, NUnit has always run all it's
7 | own tests, even those that are not really unit tests.
8 |
Now, beginning with NUnit 2.4, NUnit has top-level tests using Ward Cunningham's
9 | FIT framework. At this time, the tests are pretty rudimentary, but it's a start
10 | and it's a framework for doing more.
11 |
Running the Tests
12 | Open a console or shell window and navigate to the NUnit bin directory, which
13 | contains this file. To run the test under Microsoft .Net, enter the command
14 |
runFile NUnitFitTests.html TestResults.html .
15 | To run it under Mono, enter
16 | mono runFile.exe NUnitFitTests.html TestResults.html .
17 | Note the space and dot at the end of each command. The results of your test
18 | will be in TestResults.html in the same directory.
19 | Platform and CLR Version
20 |
21 |
22 | | NUnit.Fixtures.PlatformInfo |
23 |
24 |
25 | Verify Unit Tests
26 |
27 | Load and run the NUnit unit tests, verifying that the results are as expected.
28 | When these tests are run on different platforms, different numbers of tests may
29 | be skipped, so the values for Skipped and Run tests are informational only.
30 |
31 | The number of tests in each assembly should be constant across all platforms -
32 | any discrepancy usually means that one of the test source files was not
33 | compiled on the platform. There should be no failures and no tests ignored.
34 |
Note:
35 | At the moment, the nunit.extensions.tests assembly is failing because the
36 | fixture doesn't initialize addins in the test domain.
37 |
38 |
39 |
40 | | NUnit.Fixtures.AssemblyRunner |
41 |
42 |
43 | | Assembly |
44 | Tests() |
45 | Run() |
46 | Skipped() |
47 | Ignored() |
48 | Failures() |
49 |
50 |
51 | | nunit.framework.tests.dll |
52 | 397 |
53 | |
54 | |
55 | 0 |
56 | 0 |
57 |
58 |
59 | | nunit.core.tests.dll |
60 | 355 |
61 | |
62 | |
63 | 0 |
64 | 0 |
65 |
66 |
67 | | nunit.util.tests.dll |
68 | 238 |
69 | |
70 | |
71 | 0 |
72 | 0 |
73 |
74 |
75 | | nunit.mocks.tests.dll |
76 | 43 |
77 | |
78 | |
79 | 0 |
80 | 0 |
81 |
82 |
83 | | nunit.extensions.tests.dll |
84 | 5 |
85 | |
86 | |
87 | 0 |
88 | 0 |
89 |
90 |
91 | | nunit-console.tests.dll |
92 | 40 |
93 | |
94 | |
95 | 0 |
96 | 0 |
97 |
98 |
99 | | nunit.uikit.tests.dll |
100 | 34 |
101 | |
102 | |
103 | 0 |
104 | 0 |
105 |
106 |
107 | | nunit-gui.tests.dll |
108 | 15 |
109 | |
110 | |
111 | 0 |
112 | 0 |
113 |
114 |
115 | | nunit.fixtures.tests.dll |
116 | 6 |
117 | |
118 | |
119 | 0 |
120 | 0 |
121 |
122 |
123 | Code Snippet Tests
124 |
125 | These tests create a test assembly from a snippet of code and then load and run
126 | the tests that it contains, verifying that the structure of the loaded tests is
127 | as expected and that the number of tests run, skipped, ignored or failed is
128 | correct.
129 |
130 |
131 |
132 | | NUnit.Fixtures.SnippetRunner |
133 |
134 |
135 | | Code |
136 | Tree() |
137 | Run() |
138 | Skipped() |
139 | Ignored() |
140 | Failures() |
141 |
142 |
143 | public class TestClass
144 | {
145 | }
146 | |
147 | EMPTY |
148 | 0 |
149 | 0 |
150 | 0 |
151 | 0 |
152 |
153 |
154 | using NUnit.Framework;
155 |
156 | [TestFixture]
157 | public class TestClass
158 | {
159 | }
160 | |
161 | TestClass |
162 | 0 |
163 | 0 |
164 | 0 |
165 | 0 |
166 |
167 |
168 | using NUnit.Framework;
169 |
170 | [TestFixture]
171 | public class TestClass
172 | {
173 | [Test]
174 | public void T1() { }
175 | [Test]
176 | public void T2() { }
177 | [Test]
178 | public void T3() { }
179 | }
180 | |
181 | TestClass
182 | >T1
183 | >T2
184 | >T3
185 | |
186 | 3 |
187 | 0 |
188 | 0 |
189 | 0 |
190 |
191 |
192 | using NUnit.Framework;
193 |
194 | [TestFixture]
195 | public class TestClass1
196 | {
197 | [Test]
198 | public void T1() { }
199 | }
200 |
201 | [TestFixture]
202 | public class TestClass2
203 | {
204 | [Test]
205 | public void T2() { }
206 | [Test]
207 | public void T3() { }
208 | }
209 | |
210 | TestClass1
211 | >T1
212 | TestClass2
213 | >T2
214 | >T3
215 | |
216 | 3 |
217 | 0 |
218 | 0 |
219 | 0 |
220 |
221 |
222 | using NUnit.Framework;
223 |
224 | [TestFixture]
225 | public class TestClass
226 | {
227 | [Test]
228 | public void T1() { }
229 | [Test, Ignore]
230 | public void T2() { }
231 | [Test]
232 | public void T3() { }
233 | }
234 | |
235 | TestClass
236 | >T1
237 | >T2
238 | >T3
239 | |
240 | 2 |
241 | 0 |
242 | 1 |
243 | 0 |
244 |
245 |
246 | using NUnit.Framework;
247 |
248 | [TestFixture]
249 | public class TestClass
250 | {
251 | [Test]
252 | public void T1() { }
253 | [Test, Explicit]
254 | public void T2() { }
255 | [Test]
256 | public void T3() { }
257 | }
258 | |
259 | TestClass
260 | >T1
261 | >T2
262 | >T3
263 | |
264 | 2 |
265 | 1 |
266 | 0 |
267 | 0 |
268 |
269 |
270 | Summary Information
271 |
272 |
273 | | fit.Summary |
274 |
275 |
276 |
277 |
278 |
--------------------------------------------------------------------------------
/lib/nunit/fit-license.txt:
--------------------------------------------------------------------------------
1 |
2 |
3 | GNU GENERAL PUBLIC LICENSE
4 | Version 2, June 1991
5 |
6 | Copyright (C) 1989, 1991 Free Software Foundation, Inc.
7 | 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
8 | Everyone is permitted to copy and distribute verbatim copies
9 | of this license document, but changing it is not allowed.
10 |
11 | Preamble
12 |
13 | The licenses for most software are designed to take away your
14 | freedom to share and change it. By contrast, the GNU General Public
15 | License is intended to guarantee your freedom to share and change free
16 | software--to make sure the software is free for all its users. This
17 | General Public License applies to most of the Free Software
18 | Foundation's software and to any other program whose authors commit to
19 | using it. (Some other Free Software Foundation software is covered by
20 | the GNU Library General Public License instead.) You can apply it to
21 | your programs, too.
22 |
23 | When we speak of free software, we are referring to freedom, not
24 | price. Our General Public Licenses are designed to make sure that you
25 | have the freedom to distribute copies of free software (and charge for
26 | this service if you wish), that you receive source code or can get it
27 | if you want it, that you can change the software or use pieces of it
28 | in new free programs; and that you know you can do these things.
29 |
30 | To protect your rights, we need to make restrictions that forbid
31 | anyone to deny you these rights or to ask you to surrender the rights.
32 | These restrictions translate to certain responsibilities for you if you
33 | distribute copies of the software, or if you modify it.
34 |
35 | For example, if you distribute copies of such a program, whether
36 | gratis or for a fee, you must give the recipients all the rights that
37 | you have. You must make sure that they, too, receive or can get the
38 | source code. And you must show them these terms so they know their
39 | rights.
40 |
41 | We protect your rights with two steps: (1) copyright the software, and
42 | (2) offer you this license which gives you legal permission to copy,
43 | distribute and/or modify the software.
44 |
45 | Also, for each author's protection and ours, we want to make certain
46 | that everyone understands that there is no warranty for this free
47 | software. If the software is modified by someone else and passed on, we
48 | want its recipients to know that what they have is not the original, so
49 | that any problems introduced by others will not reflect on the original
50 | authors' reputations.
51 |
52 | Finally, any free program is threatened constantly by software
53 | patents. We wish to avoid the danger that redistributors of a free
54 | program will individually obtain patent licenses, in effect making the
55 | program proprietary. To prevent this, we have made it clear that any
56 | patent must be licensed for everyone's free use or not licensed at all.
57 |
58 | The precise terms and conditions for copying, distribution and
59 | modification follow.
60 |
61 | GNU GENERAL PUBLIC LICENSE
62 | TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
63 |
64 | 0. This License applies to any program or other work which contains
65 | a notice placed by the copyright holder saying it may be distributed
66 | under the terms of this General Public License. The "Program", below,
67 | refers to any such program or work, and a "work based on the Program"
68 | means either the Program or any derivative work under copyright law:
69 | that is to say, a work containing the Program or a portion of it,
70 | either verbatim or with modifications and/or translated into another
71 | language. (Hereinafter, translation is included without limitation in
72 | the term "modification".) Each licensee is addressed as "you".
73 |
74 | Activities other than copying, distribution and modification are not
75 | covered by this License; they are outside its scope. The act of
76 | running the Program is not restricted, and the output from the Program
77 | is covered only if its contents constitute a work based on the
78 | Program (independent of having been made by running the Program).
79 | Whether that is true depends on what the Program does.
80 |
81 | 1. You may copy and distribute verbatim copies of the Program's
82 | source code as you receive it, in any medium, provided that you
83 | conspicuously and appropriately publish on each copy an appropriate
84 | copyright notice and disclaimer of warranty; keep intact all the
85 | notices that refer to this License and to the absence of any warranty;
86 | and give any other recipients of the Program a copy of this License
87 | along with the Program.
88 |
89 | You may charge a fee for the physical act of transferring a copy, and
90 | you may at your option offer warranty protection in exchange for a fee.
91 |
92 | 2. You may modify your copy or copies of the Program or any portion
93 | of it, thus forming a work based on the Program, and copy and
94 | distribute such modifications or work under the terms of Section 1
95 | above, provided that you also meet all of these conditions:
96 |
97 | a) You must cause the modified files to carry prominent notices
98 | stating that you changed the files and the date of any change.
99 |
100 | b) You must cause any work that you distribute or publish, that in
101 | whole or in part contains or is derived from the Program or any
102 | part thereof, to be licensed as a whole at no charge to all third
103 | parties under the terms of this License.
104 |
105 | c) If the modified program normally reads commands interactively
106 | when run, you must cause it, when started running for such
107 | interactive use in the most ordinary way, to print or display an
108 | announcement including an appropriate copyright notice and a
109 | notice that there is no warranty (or else, saying that you provide
110 | a warranty) and that users may redistribute the program under
111 | these conditions, and telling the user how to view a copy of this
112 | License. (Exception: if the Program itself is interactive but
113 | does not normally print such an announcement, your work based on
114 | the Program is not required to print an announcement.)
115 |
116 | These requirements apply to the modified work as a whole. If
117 | identifiable sections of that work are not derived from the Program,
118 | and can be reasonably considered independent and separate works in
119 | themselves, then this License, and its terms, do not apply to those
120 | sections when you distribute them as separate works. But when you
121 | distribute the same sections as part of a whole which is a work based
122 | on the Program, the distribution of the whole must be on the terms of
123 | this License, whose permissions for other licensees extend to the
124 | entire whole, and thus to each and every part regardless of who wrote it.
125 |
126 | Thus, it is not the intent of this section to claim rights or contest
127 | your rights to work written entirely by you; rather, the intent is to
128 | exercise the right to control the distribution of derivative or
129 | collective works based on the Program.
130 |
131 | In addition, mere aggregation of another work not based on the Program
132 | with the Program (or with a work based on the Program) on a volume of
133 | a storage or distribution medium does not bring the other work under
134 | the scope of this License.
135 |
136 | 3. You may copy and distribute the Program (or a work based on it,
137 | under Section 2) in object code or executable form under the terms of
138 | Sections 1 and 2 above provided that you also do one of the following:
139 |
140 | a) Accompany it with the complete corresponding machine-readable
141 | source code, which must be distributed under the terms of Sections
142 | 1 and 2 above on a medium customarily used for software interchange; or,
143 |
144 | b) Accompany it with a written offer, valid for at least three
145 | years, to give any third party, for a charge no more than your
146 | cost of physically performing source distribution, a complete
147 | machine-readable copy of the corresponding source code, to be
148 | distributed under the terms of Sections 1 and 2 above on a medium
149 | customarily used for software interchange; or,
150 |
151 | c) Accompany it with the information you received as to the offer
152 | to distribute corresponding source code. (This alternative is
153 | allowed only for noncommercial distribution and only if you
154 | received the program in object code or executable form with such
155 | an offer, in accord with Subsection b above.)
156 |
157 | The source code for a work means the preferred form of the work for
158 | making modifications to it. For an executable work, complete source
159 | code means all the source code for all modules it contains, plus any
160 | associated interface definition files, plus the scripts used to
161 | control compilation and installation of the executable. However, as a
162 | special exception, the source code distributed need not include
163 | anything that is normally distributed (in either source or binary
164 | form) with the major components (compiler, kernel, and so on) of the
165 | operating system on which the executable runs, unless that component
166 | itself accompanies the executable.
167 |
168 | If distribution of executable or object code is made by offering
169 | access to copy from a designated place, then offering equivalent
170 | access to copy the source code from the same place counts as
171 | distribution of the source code, even though third parties are not
172 | compelled to copy the source along with the object code.
173 |
174 | 4. You may not copy, modify, sublicense, or distribute the Program
175 | except as expressly provided under this License. Any attempt
176 | otherwise to copy, modify, sublicense or distribute the Program is
177 | void, and will automatically terminate your rights under this License.
178 | However, parties who have received copies, or rights, from you under
179 | this License will not have their licenses terminated so long as such
180 | parties remain in full compliance.
181 |
182 | 5. You are not required to accept this License, since you have not
183 | signed it. However, nothing else grants you permission to modify or
184 | distribute the Program or its derivative works. These actions are
185 | prohibited by law if you do not accept this License. Therefore, by
186 | modifying or distributing the Program (or any work based on the
187 | Program), you indicate your acceptance of this License to do so, and
188 | all its terms and conditions for copying, distributing or modifying
189 | the Program or works based on it.
190 |
191 | 6. Each time you redistribute the Program (or any work based on the
192 | Program), the recipient automatically receives a license from the
193 | original licensor to copy, distribute or modify the Program subject to
194 | these terms and conditions. You may not impose any further
195 | restrictions on the recipients' exercise of the rights granted herein.
196 | You are not responsible for enforcing compliance by third parties to
197 | this License.
198 |
199 | 7. If, as a consequence of a court judgment or allegation of patent
200 | infringement or for any other reason (not limited to patent issues),
201 | conditions are imposed on you (whether by court order, agreement or
202 | otherwise) that contradict the conditions of this License, they do not
203 | excuse you from the conditions of this License. If you cannot
204 | distribute so as to satisfy simultaneously your obligations under this
205 | License and any other pertinent obligations, then as a consequence you
206 | may not distribute the Program at all. For example, if a patent
207 | license would not permit royalty-free redistribution of the Program by
208 | all those who receive copies directly or indirectly through you, then
209 | the only way you could satisfy both it and this License would be to
210 | refrain entirely from distribution of the Program.
211 |
212 | If any portion of this section is held invalid or unenforceable under
213 | any particular circumstance, the balance of the section is intended to
214 | apply and the section as a whole is intended to apply in other
215 | circumstances.
216 |
217 | It is not the purpose of this section to induce you to infringe any
218 | patents or other property right claims or to contest validity of any
219 | such claims; this section has the sole purpose of protecting the
220 | integrity of the free software distribution system, which is
221 | implemented by public license practices. Many people have made
222 | generous contributions to the wide range of software distributed
223 | through that system in reliance on consistent application of that
224 | system; it is up to the author/donor to decide if he or she is willing
225 | to distribute software through any other system and a licensee cannot
226 | impose that choice.
227 |
228 | This section is intended to make thoroughly clear what is believed to
229 | be a consequence of the rest of this License.
230 |
231 | 8. If the distribution and/or use of the Program is restricted in
232 | certain countries either by patents or by copyrighted interfaces, the
233 | original copyright holder who places the Program under this License
234 | may add an explicit geographical distribution limitation excluding
235 | those countries, so that distribution is permitted only in or among
236 | countries not thus excluded. In such case, this License incorporates
237 | the limitation as if written in the body of this License.
238 |
239 | 9. The Free Software Foundation may publish revised and/or new versions
240 | of the General Public License from time to time. Such new versions will
241 | be similar in spirit to the present version, but may differ in detail to
242 | address new problems or concerns.
243 |
244 | Each version is given a distinguishing version number. If the Program
245 | specifies a version number of this License which applies to it and "any
246 | later version", you have the option of following the terms and conditions
247 | either of that version or of any later version published by the Free
248 | Software Foundation. If the Program does not specify a version number of
249 | this License, you may choose any version ever published by the Free Software
250 | Foundation.
251 |
252 | 10. If you wish to incorporate parts of the Program into other free
253 | programs whose distribution conditions are different, write to the author
254 | to ask for permission. For software which is copyrighted by the Free
255 | Software Foundation, write to the Free Software Foundation; we sometimes
256 | make exceptions for this. Our decision will be guided by the two goals
257 | of preserving the free status of all derivatives of our free software and
258 | of promoting the sharing and reuse of software generally.
259 |
260 | NO WARRANTY
261 |
262 | 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
263 | FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
264 | OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
265 | PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
266 | OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
267 | MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS
268 | TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE
269 | PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
270 | REPAIR OR CORRECTION.
271 |
272 | 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
273 | WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
274 | REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
275 | INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
276 | OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
277 | TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
278 | YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
279 | PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
280 | POSSIBILITY OF SUCH DAMAGES.
281 |
282 | END OF TERMS AND CONDITIONS
283 |
284 | How to Apply These Terms to Your New Programs
285 |
286 | If you develop a new program, and you want it to be of the greatest
287 | possible use to the public, the best way to achieve this is to make it
288 | free software which everyone can redistribute and change under these terms.
289 |
290 | To do so, attach the following notices to the program. It is safest
291 | to attach them to the start of each source file to most effectively
292 | convey the exclusion of warranty; and each file should have at least
293 | the "copyright" line and a pointer to where the full notice is found.
294 |
295 |
296 | Copyright (C)
297 |
298 | This program is free software; you can redistribute it and/or modify
299 | it under the terms of the GNU General Public License as published by
300 | the Free Software Foundation; either version 2 of the License, or
301 | (at your option) any later version.
302 |
303 | This program is distributed in the hope that it will be useful,
304 | but WITHOUT ANY WARRANTY; without even the implied warranty of
305 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
306 | GNU General Public License for more details.
307 |
308 | You should have received a copy of the GNU General Public License
309 | along with this program; if not, write to the Free Software
310 | Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
311 |
312 |
313 | Also add information on how to contact you by electronic and paper mail.
314 |
315 | If the program is interactive, make it output a short notice like this
316 | when it starts in an interactive mode:
317 |
318 | Gnomovision version 69, Copyright (C) year name of author
319 | Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
320 | This is free software, and you are welcome to redistribute it
321 | under certain conditions; type `show c' for details.
322 |
323 | The hypothetical commands `show w' and `show c' should show the appropriate
324 | parts of the General Public License. Of course, the commands you use may
325 | be called something other than `show w' and `show c'; they could even be
326 | mouse-clicks or menu items--whatever suits your program.
327 |
328 | You should also get your employer (if you work as a programmer) or your
329 | school, if any, to sign a "copyright disclaimer" for the program, if
330 | necessary. Here is a sample; alter the names:
331 |
332 | Yoyodyne, Inc., hereby disclaims all copyright interest in the program
333 | `Gnomovision' (which makes passes at compilers) written by James Hacker.
334 |
335 | , 1 April 1989
336 | Ty Coon, President of Vice
337 |
338 | This General Public License does not permit incorporating your program into
339 | proprietary programs. If your program is a subroutine library, you may
340 | consider it more useful to permit linking proprietary applications with the
341 | library. If this is what you want to do, use the GNU Library General
342 | Public License instead of this License.
--------------------------------------------------------------------------------