Diese Präsentation wurde erfolgreich gemeldet.
Wir verwenden Ihre LinkedIn Profilangaben und Informationen zu Ihren Aktivitäten, um Anzeigen zu personalisieren und Ihnen relevantere Inhalte anzuzeigen. Sie können Ihre Anzeigeneinstellungen jederzeit ändern.

Structure and Interpretation of Test Cases

235 Aufrufe

Veröffentlicht am

Presented at NDC London (2019-01-31)
Video at https://www.youtube.com/watch?v=tWn8RA_DEic

Throw a line of code into many codebases and it's sure to hit one or more testing frameworks. There's no shortage of frameworks for testing, each with their particular spin and set of conventions, but that glut is not always matched by a clear vision of how to structure and use tests — a framework is a vehicle, but you still need to know how to drive. The computer science classic, Structure and Interpretation of Computer Programs, points out that "Programs must be written for people to read, and only incidentally for machines to execute". The same is true of test code.

This talk takes a deep dive into unit testing, looking at examples and counterexamples across a number of languages and frameworks, from naming to nesting, exploring the benefits of data-driven testing, the trade-offs between example-based and property-based testing, how to get the most out of the common given–when–then refrain and knowing how far to follow it.

Veröffentlicht in: Software
  • accessibility Books Library allowing access to top content, including thousands of title from favorite author, plus the ability to read or download a huge selection of books for your pc or smartphone within minutes DOWNLOAD THIS BOOKS INTO AVAILABLE FORMAT ......................................................................................................................... ......................................................................................................................... Download Full PDF EBOOK here { http://bit.ly/2m6jJ5M } ......................................................................................................................... Download Full EPUB Ebook here { http://bit.ly/2m6jJ5M } ......................................................................................................................... ...................................ALL FOR EBOOKS................................................. Cookbooks, Manga, Memoir, Music, Mystery, Non Fiction, Paranormal, Philosophy, Poetry, Psychology, Religion, Art, Biography, Business, Chick Lit, Children's, Christian, Classics, Comics, Contemporary, Romance, Science, Science Fiction, Self Help, Suspense, Spirituality, Sports, Thriller, Travel, Young Adult, Crime, Ebooks, Fantasy, Fiction, Graphic Novels, Historical Fiction, History, Horror, Humor And Comedy,
       Antworten 
    Sind Sie sicher, dass Sie …  Ja  Nein
    Ihre Nachricht erscheint hier

Structure and Interpretation of Test Cases

  1. 1. Structure and Interpretation of Test Cases @KevlinHenney
  2. 2. Programs must be written for people to read, and only incidentally for machines to execute.
  3. 3. Write Tests for People Gerard Meszaros
  4. 4. So who should you be writing the tests for? For the person trying to understand your code. Good tests act as documentation for the code they are testing. Gerard Meszaros
  5. 5. Very many people say "TDD" when they really mean, "I have good unit tests" ("I have GUTs"?). Alistair Cockburn The modern programming professional has GUTs
  6. 6. good unit tests" ("I have GUTs
  7. 7. A unit test is a test of behaviour whose success or failure is wholly determined by the correctness of the test and the correctness of the unit under test. Kevlin Henney https://www.theregister.co.uk/2007/07/28/what_are_your_units/
  8. 8. Unit testable Necessarily not unit testable Should be unit testable... but isn’t
  9. 9. The programmer in me made unit testing more about applying and exercising frameworks. I had essentially reduced my concept of unit testing to the basic mechanics of exercising xUnit to verify the behavior of my classes. My mindset had me thinking far too narrowly about what it meant to write good unit tests. Tod Golding Tapping into Testing Nirvana
  10. 10. about what it meant to write good unit tests
  11. 11. public static bool IsLeapYear(int year) 
  12. 12. [Test] public void Test() 
  13. 13. [Test] public void TestIsLeapYear() 
  14. 14. [Test] public void TestIsLeapYearIsCorrect() 
  15. 15. [Test] public void Test1()  [Test] public void Test2() 
  16. 16. [Test] public void TestLeapYears()  [Test] public void TestNonLeapYears() 
  17. 17. [Test] public void TestLeapYears() { Assert.IsTrue(IsLeapYear(2016)); Assert.IsTrue(IsLeapYear(2000)); } [Test] public void TestNonLeapYears() 
  18. 18. [Test] public void Test2016IsALeapYear()  [Test] public void Test2000IsALeapYear()  [Test] public void Test2018IsNotALeapYear()  [Test] public void Test1900IsNotALeapYear() 
  19. 19. [Test] public void _2016IsALeapYear()  [Test] public void _2000IsALeapYear()  [Test] public void _2018IsNotALeapYear()  [Test] public void _1900IsNotALeapYear() 
  20. 20. [Test] public void _2016_is_a_leap_year()  [Test] public void _2000_is_a_leap_year()  [Test] public void _2018_is_not_a_leap_year()  [Test] public void _1900_is_not_a_leap_year() 
  21. 21. _2016_is_a_leap_year _2000_is_a_leap_year _2018_is_not_a_leap_year _1900_is_not_a_leap_year
  22. 22. _2020_is_a_leap_year _2400_is_a_leap_year _2019_is_not_a_leap_year _2100_is_not_a_leap_year
  23. 23. Years_divisible_by_4_are_leap_years Years_divisible_by_400_are_leap_years Years_not_divisible_by_4_are_not_leap_years Years_divisible_by_100_are_not_leap_years
  24. 24. Years_not_divisible_by_4_are_not_leap_years Years_divisible_by_4_are_leap_years Years_divisible_by_100_are_not_leap_years Years_divisible_by_400_are_leap_years
  25. 25. Years_not_divisible_by_4_are_not_leap_years Years_divisible_by_4_but_not_by_100_are_leap_year Years_divisible_by_100_but_not_by_400_are_not_lea Years_divisible_by_400_are_leap_years
  26. 26. Years_not_divisible_by_4_are_not_leap_years Years_divisible_by_4_but_not_by_100_are_leap_years Years_divisible_by_100_but_not_by_400_are_not_leap_years Years_divisible_by_400_are_leap_years
  27. 27. IsLeapYear_YearNotDivisibleBy4_ReturnsFalse IsLeapYear_YearDivisibleBy4ButNotBy100_ReturnsTrue IsLeapYear_YearDivisibleBy100ButNotBy400_ReturnsFalse IsLeapYear_YearDivisibleBy400_ReturnsTrue
  28. 28. Propositions are vehicles for stating how things are or might be.
  29. 29. Thus only indicative sentences which it makes sense to think of as being true or as being false are capable of expressing propositions.
  30. 30. Years_not_divisible_by_4_are_not_leap_years Years_divisible_by_4_but_not_by_100_are_leap_years Years_divisible_by_100_but_not_by_400_are_not_leap_years Years_divisible_by_400_are_leap_years
  31. 31. public static bool IsLeapYear(int year) { return year % 4 == 0 && year % 100 != 0 || year % 400 == 0; }
  32. 32. Years_not_divisible_by_4_are_not_leap_years Years_divisible_by_4_but_not_by_100_are_leap_years Years_divisible_by_100_but_not_by_400_are_not_leap_years Years_divisible_by_400_are_leap_years
  33. 33. public static bool IsLeapYear(int year) { return year % 4 == 0; }
  34. 34. Years_not_divisible_by_4_are_not_leap_years Years_divisible_by_4_but_not_by_100_are_leap_years Years_divisible_by_100_but_not_by_400_are_not_leap_years Years_divisible_by_400_are_leap_years
  35. 35. For tests to drive development they must do more than just test that code performs its required functionality: they must clearly express that required functionality to the reader. That is, they must be clear specifications of the required functionality. Nat Pryce & Steve Freeman Are your tests really driving your development?
  36. 36. namespace Leap_year_spec { [TestFixture] public class A_year_is_a_leap_year { [Test] public void if_it_is_divisible_by_4_but_not_by_100()  [Test] public void if_it_is_divisible_by_400()  } [TestFixture] public class A_year_is_not_a_leap_year { [Test] public void if_it_is_not_divisible_by_4()  [Test] public void if_it_is_divisible_by_100_but_not_by_400()  } }
  37. 37. namespace Leap_year_spec { [TestFixture] public class A_year_is_a_leap_year { [Test] public void if_it_is_divisible_by_4_but_not_by_100()  [Test] public void if_it_is_divisible_by_400()  } [TestFixture] public class A_year_is_not_a_leap_year { [Test] public void if_it_is_not_divisible_by_4()  [Test] public void if_it_is_divisible_by_100_but_not_by_400()  } }
  38. 38. namespace Leap_year_spec { [TestFixture] public class A_year_is_a_leap_year  [TestFixture] public class A_year_is_not_a_leap_year { [Test] public void if_it_is_not_divisible_by_4() { Assert.IsFalse(IsLeapYear(2018)); } [Test] public void if_it_is_divisible_by_100_but_not_by_400() { Assert.IsFalse(IsLeapYear(1900)); } } }
  39. 39. namespace Leap_year_spec { [TestFixture] public class A_year_is_a_leap_year  [TestFixture] public class A_year_is_not_a_leap_year { [Test] public void if_it_is_not_divisible_by_4() { Assert.IsFalse(isLeapYear(2018)); } [Test] public void if_it_is_divisible_by_100_but_not_by_400() { Assert.IsFalse(isLeapYear(1900)); } } }
  40. 40. namespace Leap_year_spec { [TestFixture] public class A_year_is_a_leap_year  [TestFixture] public class A_year_is_not_a_leap_year { [Test] public void if_it_is_not_divisible_by_4() { Assert.IsFalse(isLeapYear(42)); } [Test] public void if_it_is_divisible_by_100_but_not_by_400() { Assert.IsFalse(isLeapYear(100)); } } }
  41. 41. namespace Leap_year_spec { [TestFixture] public class A_year_is_a_leap_year  [TestFixture] public class A_year_is_not_a_leap_year { [Test] public void if_it_is_not_divisible_by_4() { Assert.IsFalse(IsLeapYear(2018)); Assert.IsFalse(IsLeapYear(2017)); Assert.IsFalse(IsLeapYear(42)); Assert.IsFalse(IsLeapYear(1)); } [Test] public void if_it_is_divisible_by_100_but_not_by_400()  } }
  42. 42. namespace Leap_year_spec { [TestFixture] public class A_year_is_a_leap_year  [TestFixture] public class A_year_is_not_a_leap_year { [TestCase(2018)] [TestCase(2017)] [TestCase(42)] [TestCase(1)] public void if_it_is_not_divisible_by_4(int year) { Assert.IsFalse(IsLeapYear(year)); } [Test] public void if_it_is_divisible_by_100_but_not_by_400()  } }
  43. 43. namespace Leap_year_spec { [TestFixture] public class A_year_is_a_leap_year  [TestFixture] public class A_year_is_not_a_leap_year { [Test] public void if_it_is_not_divisible_by_4( [Values(2018, 2017, 42, 1)] int year) { Assert.IsFalse(IsLeapYear(year)); } [Test] public void if_it_is_divisible_by_100_but_not_by_400()  } }
  44. 44. namespace Leap_year_spec { [TestFixture] public class A_year_is_a_leap_year { [Test] public void if_it_is_divisible_by_4_but_not_by_100( [Values(2016, 1984, 4)] int year)  [Test] public void if_it_is_divisible_by_400( [Range(400, 2400, 400)] int year)  } [TestFixture] public class A_year_is_not_a_leap_year { [Test] public void if_it_is_not_divisible_by_4( [Values(2018, 2017, 42, 1)] int year)  [Test] public void if_it_is_divisible_by_100_but_not_by_400( [Values(2100, 1900, 100)] int year)  } }
  45. 45. namespace Leap_year_spec { [TestFixture] public class A_year_is_a_leap_year { [Test] public void if_it_is_divisible_by_4_but_not_by_100( [Values(2016, 1984, 4)] int year)  [Test] public void if_it_is_divisible_by_400( [Range(400, 2400, 400)] int year)  } [TestFixture] public class A_year_is_not_a_leap_year { [Test] public void if_it_is_not_divisible_by_4( [Values(2018, 2017, 42, 1)] int year)  [Test] public void if_it_is_divisible_by_100_but_not_by_400( [Values(2100, 1900, 100)] int year)  } }
  46. 46. namespace Leap_year_spec { [TestFixture] public class A_year { [Test] public void is_either_a_leap_year_or_not([Range(1, 10000)] int year)  } }
  47. 47. namespace Leap_year_spec { [TestFixture] public class A_year { [Test] public void is_either_a_leap_year_or_not([Range(1, 10000)] int year)  } }
  48. 48. namespace Leap_year_spec { [TestFixture] public class A_year { [Test] public void is_either_a_leap_year_or_not([Range(1, 10000)] int year) { Assert.AreEqual( year % 4 == 0 && year % 100 != 0 || year % 400 == 0, IsLeapYear(year)); } } }
  49. 49. namespace Leap_year_spec { [TestFixture] public class A_year { [Test] public void is_either_a_leap_year_or_not([Range(1, 10000)] int year) { Assert.AreEqual(LeapYearExpectation(year), IsLeapYear(year)); } public static bool LeapYearExpectation(int year) { return year % 4 == 0 && year % 100 != 0 || year % 400 == 0; } } }
  50. 50. public static bool IsLeapYear(int year) { return year % 4 == 0 && year % 100 != 0 || year % 400 == 0; }
  51. 51. All happy families are alike; each unhappy family is unhappy in its own way. Leo Tolstoy Anna Karenina
  52. 52. namespace Leap_year_spec { [TestFixture] public class A_year_is_a_leap_year  [TestFixture] public class A_year_is_not_a_leap_year  [TestFixture] public class A_year_is_not_supported { [Test] public void if_it_is_0() { Assert.Throws<ArgumentException>(() => IsLeapYear(0)); } } }
  53. 53. namespace Leap_year_spec { [TestFixture] public class A_year_is_a_leap_year  [TestFixture] public class A_year_is_not_a_leap_year  [TestFixture] public class A_year_is_not_supported { [Test] public void if_it_is_0() { Assert.Catch<ArgumentException>(() => IsLeapYear(0)); } } }
  54. 54. namespace Leap_year_spec { [TestFixture] public class A_year_is_a_leap_year  [TestFixture] public class A_year_is_not_a_leap_year  [TestFixture] public class A_year_is_not_supported { [Test] public void if_it_is_0() { Assert.Catch<ArgumentException>(() => IsLeapYear(0)); } [Test] public void if_it_is_negative( [Values(-1, -4, -100, -400)] int year) { Assert.Catch<ArgumentException>(() => IsLeapYear(year)); } } }
  55. 55. namespace Leap_year_spec { [TestFixture] public class A_year_is_a_leap_year  [TestFixture] public class A_year_is_not_a_leap_year  [TestFixture] public class A_year_is_supported { [Test] public void if_it_is_positive( [Values(1, int.MaxValue)] int year) { Assert.DoesNotThrow(() => IsLeapYear(year)); } } [TestFixture] public class A_year_is_not_supported  }
  56. 56. Stack {new, push, pop, depth, top}
  57. 57. An abstract data type defines a class of abstract objects which is completely characterized by the operations available on those objects. Barbara Liskov Programming with Abstract Data Types
  58. 58.  T •  Stack { new: Stack[T], push: Stack[T]  T → Stack[T], pop: Stack[T] ⇸ Stack[T], depth: Stack[T] → Integer, top: Stack[T] ⇸ T }
  59. 59. template<typename T> class stack { public: stack(); void push(const T & new_top); void pop(); std::size_t depth() const; T top() const; private: ... };
  60. 60. TEST_CASE(“test stack::stack”)  TEST_CASE(“test stack::push”)  TEST_CASE(“test stack::pop”)  TEST_CASE(“test stack::depth”)  TEST_CASE(“test stack::top”) 
  61. 61. TEST_CASE(“stack tests”) { SECTION(“test constructor”)  SECTION(“test push”)  SECTION(“test pop”)  SECTION(“test depth”)  SECTION(“test top”)  }
  62. 62. TEST_CASE(“stack tests”) { SECTION(“constructor”)  SECTION(“push”)  SECTION(“pop”)  SECTION(“depth”)  SECTION(“top”)  }
  63. 63. template<typename T> class stack { public: stack(); void push(const T & new_top); void pop(); std::size_t depth() const; T top() const; private: ... };
  64. 64. template<typename T> class stack { public: stack() = default; void push(const T & new_top); void pop(); std::size_t depth() const; T top() const; private: ... };
  65. 65. TEST_CASE(“stack tests”) { SECTION(“constructor”)  SECTION(“push”)  SECTION(“pop”)  SECTION(“depth”)  SECTION(“top”)  }
  66. 66. TEST_CASE(“stack tests”) { SECTION(“push”)  SECTION(“pop”)  SECTION(“depth”)  SECTION(“top”)  }
  67. 67. TEST_CASE(“stack tests”) { SECTION(“can be constructed”)  SECTION(“can be pushed”)  SECTION(“can be popped”)  SECTION(“has depth”)  SECTION(“has a top”)  }
  68. 68. TEST_CASE(“stack tests”) { SECTION(“can be constructed”)  SECTION(“can be pushed”)  SECTION(“can sometimes be popped”)  SECTION(“has depth”)  SECTION(“sometimes has a top”)  }
  69. 69. https://twitter.com/chrisoldwood/status/918139432447954944
  70. 70. Given When Then an empty stack an item is pushed it should not be empty
  71. 71. Given When Then an empty stack an item is pushed if it's OK with you, I think that, perhaps, it should probably not be empty, don't you think?
  72. 72. Make definite assertions. Avoid tame, colourless, hesitating, noncommittal language. When a sentence is made stronger, it usually becomes shorter. Thus brevity is a by-product of vigour. William Strunk and E B White The Elements of Style
  73. 73. Given When Then an empty stack an item is pushed it must not be empty
  74. 74. Given When Then an empty stack an item is pushed it is not empty
  75. 75. Given When Then And an empty stack an item is pushed it has a depth of 1 the top item is the item that was pushed
  76. 76. GivenAnEmptyStackWhenAnI temIsPushedThenItHasADep thOf1AndTheTopItemIsTheI temThatWasPushed
  77. 77. Given_an_empty_stack_Whe n_an_item_is_pushed_Then _it_has_a_depth_of_1_And _the_top_item_is_the_ite m_that_was_pushed
  78. 78. Given an empty stack When an item is pushed Then it has a depth of 1 And the top item is the item that was pushed
  79. 79. An empty stack acquires depth by retaining a pushed item as its top
  80. 80. Omit needless words. William Strunk and E B White The Elements of Style
  81. 81. TEST_CASE(“Stack specification”) {  SECTION(“An empty stack acquires depth by retaining a pushed item as its top") { stack<std::string> stack; stack.push(“NDC"); REQUIRE(stack.depth() == 1); REQUIRE(stack.top() == “NDC"); }  }
  82. 82. TEST_CASE(“Stack specification”) { SECTION(“A new stack is empty”)  SECTION(“An empty stack throws when queried for its top item”)  SECTION(“An empty stack throws when popped”)  SECTION(“An empty stack acquires depth by retaining a pushed item as its top”)  SECTION(“A non-empty stack becomes deeper by retaining a pushed item as its top”)  SECTION(“A non-empty stack on popping reveals tops in reverse order of pushing”)  }
  83. 83. TEST_CASE(“Stack specification”) { SECTION(“A new stack is empty”)  SECTION(“An empty stack throws when queried for its top item”)  SECTION(“An empty stack throws when popped”)  SECTION(“An empty stack acquires depth by retaining a pushed item as its top”)  SECTION(“A non-empty stack becomes deeper by retaining a pushed item as its top”)  SECTION(“A non-empty stack on popping reveals tops in reverse order of pushing”)  }
  84. 84. TEST_CASE(“Stack specification”) {  SECTION(“An empty stack acquires depth by retaining a pushed item as its top") { stack<std::string> stack; stack.push(“NDC"); REQUIRE(stack.depth() == 1); REQUIRE(stack.top() == “NDC"); }  }
  85. 85. For each usage scenario, the test(s): ▪ Describe the context, starting point, or preconditions that must be satisfied ▪ Illustrate how the software is invoked ▪ Describe the expected results or postconditions to be verified Gerard Meszaros
  86. 86. TEST_CASE(“Stack specification”) {  SECTION(“An empty stack acquires depth by retaining a pushed item as its top") { // Arrange: stack<std::string> stack; // Act: stack.push(“NDC"); // Assert: REQUIRE(stack.depth() == 1); REQUIRE(stack.top() == “NDC"); }  }
  87. 87. TEST_CASE(“Stack specification”) {  SECTION(“An empty stack acquires depth by retaining a pushed item as its top") { // Arrange: stack<std::string> stack; // Act: stack.push(“NDC"); // Assert: REQUIRE(stack.depth() == 1); REQUIRE(stack.top() == “NDC"); }  }
  88. 88. TEST_CASE(“Stack specification”) {  SECTION(“An empty stack acquires depth by retaining a pushed item as its top") { // Given: stack<std::string> stack; // When: stack.push(“NDC"); // Then: REQUIRE(stack.depth() == 1); REQUIRE(stack.top() == “NDC"); }  }
  89. 89. https://twitter.com/jasongorman/status/572829496342134784
  90. 90. {P} Q {R}
  91. 91. Communications of the ACM, 12(10), October 1969
  92. 92. P {Q} R
  93. 93. If the assertion P is true before initiation of a program Q, then the assertion R will be true on its completion.
  94. 94. Non-EmptyEmpty depth depth top push pop [depth > 1] push pop [depth = 1] new
  95. 95. Non-EmptyEmpty depth top / error pop / error depth top push pop [depth > 1] push pop [depth = 1] new
  96. 96. TEST_CASE("Stack specification") { SECTION("A new stack") { SECTION("is empty") ... } SECTION("An empty stack") { SECTION("throws when queried for its top item") ... SECTION("throws when popped") ... SECTION("acquires depth by retaining a pushed item as its top") ... } SECTION("A non empty stack") { SECTION("becomes deeper by retaining a pushed item as its top") ... SECTION("on popping reveals tops in reverse order of pushing") ... } }
  97. 97. TEST_CASE("Stack specification") { SECTION("A new stack") { SECTION("is empty") ... } SECTION("An empty stack") { SECTION("throws when queried for its top item") ... SECTION("throws when popped") ... SECTION("acquires depth by retaining a pushed item as its top") ... } SECTION("A non empty stack") { SECTION("becomes deeper by retaining a pushed item as its top") ... SECTION("on popping reveals tops in reverse order of pushing") ... } }
  98. 98. TEST_CASE("Stack specification") { SECTION("A new stack") { ... } SECTION("An empty stack") { ... SECTION("acquires depth by retaining a pushed item as its top") { stack<std::string> stack; stack.push(“NDC"); REQUIRE(stack.depth() == 1); REQUIRE(stack.top() == “NDC"); } } SECTION("A non empty stack") { ... } }
  99. 99. TEST_CASE("Stack specification") { SECTION("A new stack") { ... } SECTION("An empty stack") { stack<std::string> stack; ... SECTION("acquires depth by retaining a pushed item as its top") { stack.push(“NDC"); REQUIRE(stack.depth() == 1); REQUIRE(stack.top() == “NDC"); } } SECTION("A non empty stack") { ... } }
  100. 100. SCENARIO("Stack specification") { ... GIVEN("An empty stack") { stack<std::string> stack; ... WHEN("an item is pushed") { stack.push(“NDC"); THEN(“acquires depth by retaining the new item as its top”) { REQUIRE(stack.depth() == 1); REQUIRE(stack.top() == “NDC"); } } } ... }
  101. 101. SCENARIO("Stack specification") { ... GIVEN("An empty stack") { stack<std::string> stack; ... WHEN("an item is pushed") { stack.push(“NDC"); THEN(“acquires depth”) { REQUIRE(stack.depth() == 1); } THEN(“retains the new item as its top”) { REQUIRE(stack.top() == “NDC"); } } } ... }
  102. 102. SCENARIO("Stack specification") { ... GIVEN("An empty stack") { stack<std::string> stack; ... WHEN("an item is pushed") { stack.push(“NDC"); THEN(“acquires depth”) REQUIRE(stack.depth() == 1); THEN(“retains the new item as its top”) REQUIRE(stack.top() == “NDC"); } } ... }
  103. 103. Given can be used to group tests for operations with respect to common initial state
  104. 104. When can be used to group tests by operation, regardless of initial state or outcome
  105. 105. Then can be used to group tests by common outcome, regardless of operation or initial state
  106. 106. Queue {new, length, capacity, enqueue, dequeue}
  107. 107. producer consumerspacetime decoupling
  108. 108. N buffered bounded asynchronous
  109. 109. N = buffered unbounded asynchronous ∞
  110. 110. N = 1 buffered bounded asynchronous futurepromise
  111. 111. N = 0 unbuffered bounded synchronous
  112. 112. public class Queue<T> { ... public Queue(int capacity) ... public int length() ... public int capacity() ... public boolean enqueue(T last) ... public Optional<T> dequeue() ... }
  113. 113. Non-EmptyEmpty length capacity dequeue length capacity enqueue dequeue [length > 1] enqueue dequeue [length = 1] new [capacity > 0]
  114. 114. Non-Full Empty length capacity dequeue length capacity enqueue dequeue [length > 1] enqueue dequeue [length = 1] new [capacity > 0] Full Non-Empty [length = capacity] [length < capacity]
  115. 115. public class Queue_spec  public class A_new_queue  public void is_empty()  public void preserves_positive_bounding_capacity(int capacity)  public void cannot_be_created_with_non_positive_bounding_capacity(int capacity)  public class An_empty_queue  public void dequeues_an_empty_value()  public void remains_empty_when_null_enqueued()  public void becomes_non_empty_when_non_null_value_enqueued(String value)  public class A_non_empty_queue  public class that_is_not_full  public void becomes_longer_when_non_null_value_enqueued(String value)  public void becomes_full_when_enqueued_up_to_capacity()  public class that_is_full  public void ignores_further_enqueued_values()  public void becomes_non_full_when_dequeued()  public void dequeues_values_in_order_enqueued()  public void remains_unchanged_when_null_enqueued() 
  116. 116. public class Queue_spec  public class A_new_queue  public void is_empty()  public void preserves_positive_bounding_capacity(int capacity)  public void cannot_be_created_with_non_positive_bounding_capacity(int capacity)  public class An_empty_queue  public void dequeues_an_empty_value()  public void remains_empty_when_null_enqueued()  public void becomes_non_empty_when_non_null_value_enqueued(String value)  public class A_non_empty_queue  public class that_is_not_full  public void becomes_longer_when_non_null_value_enqueued(String value)  public void becomes_full_when_enqueued_up_to_capacity()  public class that_is_full  public void ignores_further_enqueued_values()  public void becomes_non_full_when_dequeued()  public void dequeues_values_in_order_enqueued()  public void remains_unchanged_when_null_enqueued() 
  117. 117. public class Queue<T> { private Deque<T> items = new LinkedList<>(); private final int capacity; public Queue(int boundingCapacity) { if (boundingCapacity < 1) throw new IllegalArgumentException(); capacity = boundingCapacity; } public int length() { return items.size(); } public int capacity() { return capacity; } public boolean enqueue(T last) { boolean enqueuing = last != null && length() < capacity(); if (enqueuing) items.addLast(last); return enqueuing; } public Optional<T> dequeue() { return Optional.ofNullable(items.pollFirst()); } }

×