From 05596b328bbcb6f854fa91a44c719bf03ad4fb91 Mon Sep 17 00:00:00 2001 From: Amy Gill Date: Fri, 9 Mar 2018 11:03:56 -0500 Subject: [PATCH 1/8] wading --- src/main/java/Stack.java | 5 ++ src/main/java/StackArray/GenericStack.java | 8 +- .../java/StackArray/GenericStackTest.java | 82 +++++++++---------- 3 files changed, 53 insertions(+), 42 deletions(-) create mode 100644 src/main/java/Stack.java diff --git a/src/main/java/Stack.java b/src/main/java/Stack.java new file mode 100644 index 0000000..6090164 --- /dev/null +++ b/src/main/java/Stack.java @@ -0,0 +1,5 @@ +public class Stack{ + public boolean isEmpty(){ + return false; + } +} \ No newline at end of file diff --git a/src/main/java/StackArray/GenericStack.java b/src/main/java/StackArray/GenericStack.java index d84c4db..b40895a 100644 --- a/src/main/java/StackArray/GenericStack.java +++ b/src/main/java/StackArray/GenericStack.java @@ -1,15 +1,21 @@ package StackArray; import java.util.Arrays; +import java.util.Stack; /** * Expand the ArrayList implementation of stack here to use an E[] array. Still implement push, pop, and isEmpty. * Remember, you might need to resize the stack in the push method. * @param */ -public class GenericStack { +public class GenericStack extends Stack { private E[] elements; public GenericStack() { } + + @Override + public synchronized boolean isEmpty() { + return super.isEmpty(); + } } diff --git a/src/test/java/StackArray/GenericStackTest.java b/src/test/java/StackArray/GenericStackTest.java index 0aacd92..c61b904 100644 --- a/src/test/java/StackArray/GenericStackTest.java +++ b/src/test/java/StackArray/GenericStackTest.java @@ -1,41 +1,41 @@ -//package StackArray; -// -//import org.junit.Assert; -//import org.junit.Test; -// -//public class GenericStackTest { -// @Test -// public void testPushingGrowsTheStack() throws Exception { -// // Given an empty stack -// GenericStack stack = new GenericStack<>(); -// -// // Assert that it is empty. -// Assert.assertEquals(true, stack.isEmpty()); -// // When we push something onto the stack -// stack.push("foobar"); -// // Then it shouldn't be empty -// Assert.assertEquals(false, stack.isEmpty()); -// } -// -// @Test -// public void testPushingAndPoppingOrder() throws Exception { -// // Given an empty stack -// GenericStack stack = new GenericStack<>(); -// // When we push two elements on it -// stack.push("foo"); -// stack.push("bar"); -// // Then we should see them returned in the correct order -// Assert.assertEquals("bar", stack.pop()); -// Assert.assertEquals("foo", stack.pop()); -// } -// -// @Test(expected = IndexOutOfBoundsException.class) -// public void testPopFirst() throws Exception { -// // Given an empty stack -// GenericStack stack = new GenericStack<>(); -// // When it's popped -// stack.pop(); -// // Then we should get an exception -// } -// -//} \ No newline at end of file +package StackArray; + +import org.junit.Assert; +import org.junit.Test; + +public class GenericStackTest { + @Test + public void testPushingGrowsTheStack() throws Exception { + // Given an empty stack + GenericStack stack = new GenericStack<>(); + + // Assert that it is empty. + Assert.assertEquals(true, stack.isEmpty()); + // When we push something onto the stack + stack.push("foobar"); + // Then it shouldn't be empty + Assert.assertEquals(false, stack.isEmpty()); + } + + @Test + public void testPushingAndPoppingOrder() throws Exception { + // Given an empty stack + GenericStack stack = new GenericStack<>(); + // When we push two elements on it + stack.push("foo"); + stack.push("bar"); + // Then we should see them returned in the correct order + Assert.assertEquals("bar", stack.pop()); + Assert.assertEquals("foo", stack.pop()); + } + + @Test(expected = IndexOutOfBoundsException.class) + public void testPopFirst() throws Exception { + // Given an empty stack + GenericStack stack = new GenericStack<>(); + // When it's popped + stack.pop(); + // Then we should get an exception + } + +} \ No newline at end of file From a6113fdaf11aafbddfc739f5e918a1138fcca0a4 Mon Sep 17 00:00:00 2001 From: Amy Gill Date: Fri, 9 Mar 2018 14:56:45 -0500 Subject: [PATCH 2/8] a --- src/main/java/Stack.java | 10 +++++----- src/main/java/StackArray/GenericStack.java | 15 +++++++++++---- 2 files changed, 16 insertions(+), 9 deletions(-) diff --git a/src/main/java/Stack.java b/src/main/java/Stack.java index 6090164..06bc009 100644 --- a/src/main/java/Stack.java +++ b/src/main/java/Stack.java @@ -1,5 +1,5 @@ -public class Stack{ - public boolean isEmpty(){ - return false; - } -} \ No newline at end of file +//public class Stack { +// public boolean isEmpty(){ +// return false; +// } +//} \ No newline at end of file diff --git a/src/main/java/StackArray/GenericStack.java b/src/main/java/StackArray/GenericStack.java index b40895a..77bda53 100644 --- a/src/main/java/StackArray/GenericStack.java +++ b/src/main/java/StackArray/GenericStack.java @@ -8,14 +8,21 @@ * Remember, you might need to resize the stack in the push method. * @param */ -public class GenericStack extends Stack { +public class GenericStack { private E[] elements; + GenericStack myStack = new GenericStack<>(); + public GenericStack() { } - @Override - public synchronized boolean isEmpty() { - return super.isEmpty(); + public E isEmpty() { + + } + + public void push(E foobar) { + } + + public E pop() { } } From 951a81eec83d3a2dcb732f005d0d6b52b1bb75ce Mon Sep 17 00:00:00 2001 From: Amy Gill Date: Mon, 12 Mar 2018 15:48:07 -0400 Subject: [PATCH 3/8] Stack tests passing --- src/main/java/Pair/Arrays.java | 32 +++---- src/main/java/StackArray/GenericStack.java | 56 ++++++------ src/main/java/StackArrayList/Stack.java | 19 ++++ .../java/StackArray/GenericStackTest.java | 82 ++++++++--------- src/test/java/StackArrayList/StackTest.java | 90 +++++++++---------- 5 files changed, 149 insertions(+), 130 deletions(-) diff --git a/src/main/java/Pair/Arrays.java b/src/main/java/Pair/Arrays.java index 5bdf780..502e04a 100644 --- a/src/main/java/Pair/Arrays.java +++ b/src/main/java/Pair/Arrays.java @@ -1,16 +1,16 @@ -package Pair; - -import java.util.ArrayList; -import java.util.Collections; - -/** - * In here you must make firstLast, which will return a pair of the first element in the array list and the last - * element in the arraylist. - * You must also make a min method that returns the smallest item in the array list - * A max method that returns the largest item in the arraylist - * And a minmax method that returns a pair containing the largest and smallest items from the array list - */ -public class Arrays { - public static <___> Pair firstLast(ArrayList<___> a) { - } -} +//package Pair; +// +//import java.util.ArrayList; +//import java.util.Collections; +// +///** +// * In here you must make firstLast, which will return a pair of the first element in the array list and the last +// * element in the arraylist. +// * You must also make a min method that returns the smallest item in the array list +// * A max method that returns the largest item in the arraylist +// * And a minmax method that returns a pair containing the largest and smallest items from the array list +// */ +//public class Arrays { +// public static <___> Pair firstLast(ArrayList<___> a) { +// } +//} diff --git a/src/main/java/StackArray/GenericStack.java b/src/main/java/StackArray/GenericStack.java index 77bda53..aec52b3 100644 --- a/src/main/java/StackArray/GenericStack.java +++ b/src/main/java/StackArray/GenericStack.java @@ -1,28 +1,28 @@ -package StackArray; - -import java.util.Arrays; -import java.util.Stack; - -/** - * Expand the ArrayList implementation of stack here to use an E[] array. Still implement push, pop, and isEmpty. - * Remember, you might need to resize the stack in the push method. - * @param - */ -public class GenericStack { - private E[] elements; - - GenericStack myStack = new GenericStack<>(); - - public GenericStack() { - } - - public E isEmpty() { - - } - - public void push(E foobar) { - } - - public E pop() { - } -} +//package StackArray; +// +//import java.util.Arrays; +//import java.util.Stack; +// +///** +// * Expand the ArrayList implementation of stack here to use an E[] array. Still implement push, pop, and isEmpty. +// * Remember, you might need to resize the stack in the push method. +// * @param +// */ +//public class GenericStack { +// private E[] elements; +// +// GenericStack myStack = new GenericStack<>(); +// +// public GenericStack() { +// } +// +// public E isEmpty() { +// +// } +// +// public void push(E foobar) { +// } +// +// public E pop() { +// } +//} diff --git a/src/main/java/StackArrayList/Stack.java b/src/main/java/StackArrayList/Stack.java index 0338de3..1f808e1 100644 --- a/src/main/java/StackArrayList/Stack.java +++ b/src/main/java/StackArrayList/Stack.java @@ -7,10 +7,29 @@ * If you pop on an empty stack, throw an IndexOutOfBoundsException. */ public class Stack { + private ArrayList elements; public Stack(){ + this.elements = new ArrayList(); + } + + public boolean isEmpty() { + boolean answer = false; + answer = elements.size()==0; + + return answer; + } + + public void push(E foobar) { + elements.add(foobar); + + } + public E pop() { + E lastElement = (E) elements.get(elements.size()-1); + elements.remove(elements.size()-1); + return lastElement; } } diff --git a/src/test/java/StackArray/GenericStackTest.java b/src/test/java/StackArray/GenericStackTest.java index c61b904..0aacd92 100644 --- a/src/test/java/StackArray/GenericStackTest.java +++ b/src/test/java/StackArray/GenericStackTest.java @@ -1,41 +1,41 @@ -package StackArray; - -import org.junit.Assert; -import org.junit.Test; - -public class GenericStackTest { - @Test - public void testPushingGrowsTheStack() throws Exception { - // Given an empty stack - GenericStack stack = new GenericStack<>(); - - // Assert that it is empty. - Assert.assertEquals(true, stack.isEmpty()); - // When we push something onto the stack - stack.push("foobar"); - // Then it shouldn't be empty - Assert.assertEquals(false, stack.isEmpty()); - } - - @Test - public void testPushingAndPoppingOrder() throws Exception { - // Given an empty stack - GenericStack stack = new GenericStack<>(); - // When we push two elements on it - stack.push("foo"); - stack.push("bar"); - // Then we should see them returned in the correct order - Assert.assertEquals("bar", stack.pop()); - Assert.assertEquals("foo", stack.pop()); - } - - @Test(expected = IndexOutOfBoundsException.class) - public void testPopFirst() throws Exception { - // Given an empty stack - GenericStack stack = new GenericStack<>(); - // When it's popped - stack.pop(); - // Then we should get an exception - } - -} \ No newline at end of file +//package StackArray; +// +//import org.junit.Assert; +//import org.junit.Test; +// +//public class GenericStackTest { +// @Test +// public void testPushingGrowsTheStack() throws Exception { +// // Given an empty stack +// GenericStack stack = new GenericStack<>(); +// +// // Assert that it is empty. +// Assert.assertEquals(true, stack.isEmpty()); +// // When we push something onto the stack +// stack.push("foobar"); +// // Then it shouldn't be empty +// Assert.assertEquals(false, stack.isEmpty()); +// } +// +// @Test +// public void testPushingAndPoppingOrder() throws Exception { +// // Given an empty stack +// GenericStack stack = new GenericStack<>(); +// // When we push two elements on it +// stack.push("foo"); +// stack.push("bar"); +// // Then we should see them returned in the correct order +// Assert.assertEquals("bar", stack.pop()); +// Assert.assertEquals("foo", stack.pop()); +// } +// +// @Test(expected = IndexOutOfBoundsException.class) +// public void testPopFirst() throws Exception { +// // Given an empty stack +// GenericStack stack = new GenericStack<>(); +// // When it's popped +// stack.pop(); +// // Then we should get an exception +// } +// +//} \ No newline at end of file diff --git a/src/test/java/StackArrayList/StackTest.java b/src/test/java/StackArrayList/StackTest.java index 0ce7cf0..00dc659 100644 --- a/src/test/java/StackArrayList/StackTest.java +++ b/src/test/java/StackArrayList/StackTest.java @@ -1,45 +1,45 @@ -//package StackArrayList; -// -//import org.junit.Test; -// -//import org.junit.Assert; -// -//public class StackTest { -// @Test -// public void testEmptyStackStopsBeingEmptyWhenAnItemIsAdded() throws Exception { -// // Given an empty stack -// Stack stack = new Stack<>(); -// // Assert that it starts empty -// Assert.assertEquals(true, stack.isEmpty()); -// // When an element gets pushed -// stack.push("foobar"); -// // Then the stack should not be empty. -// Assert.assertEquals(false, stack.isEmpty()); -// } -// -// @Test -// public void testTwoItemsPushedComeOutInCorrectOrder() throws Exception { -// // Given an empty stack -// Stack stack = new Stack<>(); -// -// //When two items are pushed -// stack.push("foo"); -// stack.push("bar"); -// -// // Then they should come off in reverse order. -// Assert.assertEquals("bar", stack.pop()); -// Assert.assertEquals("foo", stack.pop()); -// -// // And then the stack should be empty -// Assert.assertEquals(true, stack.isEmpty()); -// } -// -// @Test(expected = IndexOutOfBoundsException.class) -// public void testPopFirst() throws Exception { -// // Given an empty stack -// Stack stack = new Stack<>(); -// // Then it is popped -// stack.pop(); -// // We should get an exception -// } -//} \ No newline at end of file +package StackArrayList; + +import org.junit.Test; + +import org.junit.Assert; + +public class StackTest { + @Test + public void testEmptyStackStopsBeingEmptyWhenAnItemIsAdded() throws Exception { + // Given an empty stack + Stack stack = new Stack<>(); + // Assert that it starts empty + Assert.assertEquals(true, stack.isEmpty()); + // When an element gets pushed + stack.push("foobar"); + // Then the stack should not be empty. + Assert.assertEquals(false, stack.isEmpty()); + } + + @Test + public void testTwoItemsPushedComeOutInCorrectOrder() throws Exception { + // Given an empty stack + Stack stack = new Stack<>(); + + //When two items are pushed + stack.push("foo"); + stack.push("bar"); + + // Then they should come off in reverse order. + Assert.assertEquals("bar", stack.pop()); + Assert.assertEquals("foo", stack.pop()); + + // And then the stack should be empty + Assert.assertEquals(true, stack.isEmpty()); + } + + @Test(expected = IndexOutOfBoundsException.class) + public void testPopFirst() throws Exception { + // Given an empty stack + Stack stack = new Stack<>(); + // Then it is popped + stack.pop(); + // We should get an exception + } +} \ No newline at end of file From e961d9d2eb8c11f73742e79ac3d1b4f422dcf2fe Mon Sep 17 00:00:00 2001 From: Amy Gill Date: Mon, 12 Mar 2018 16:39:45 -0400 Subject: [PATCH 4/8] generic stack complete --- src/main/java/StackArray/GenericStack.java | 69 +++++++++------- .../java/StackArray/GenericStackTest.java | 82 +++++++++---------- 2 files changed, 82 insertions(+), 69 deletions(-) diff --git a/src/main/java/StackArray/GenericStack.java b/src/main/java/StackArray/GenericStack.java index aec52b3..4c4c527 100644 --- a/src/main/java/StackArray/GenericStack.java +++ b/src/main/java/StackArray/GenericStack.java @@ -1,28 +1,41 @@ -//package StackArray; -// -//import java.util.Arrays; -//import java.util.Stack; -// -///** -// * Expand the ArrayList implementation of stack here to use an E[] array. Still implement push, pop, and isEmpty. -// * Remember, you might need to resize the stack in the push method. -// * @param -// */ -//public class GenericStack { -// private E[] elements; -// -// GenericStack myStack = new GenericStack<>(); -// -// public GenericStack() { -// } -// -// public E isEmpty() { -// -// } -// -// public void push(E foobar) { -// } -// -// public E pop() { -// } -//} +package StackArray; + +import java.util.Arrays; +import java.util.Stack; + +/** + * Expand the ArrayList implementation of stack here to use an E[] array. Still implement push, pop, and isEmpty. + * Remember, you might need to resize the stack in the push method. + * @param + */ +public class GenericStack { + private E[] elements; + + // GenericStack myStack = new GenericStack<>(); + + public GenericStack() { + elements = (E[]) new Object[0]; + + //casting to just an object: (not array) + // element = (E) new Object; + + } + + public boolean isEmpty() { + + return elements.length==0; + + } + + public void push(E foobar) { + elements= Arrays.copyOf(elements, elements.length+1); + elements[elements.length-1] = foobar; + } + + + public E pop() { + E lastElement = (E) elements[elements.length-1]; + elements=Arrays.copyOf(elements,elements.length-1); + return lastElement; + } +} diff --git a/src/test/java/StackArray/GenericStackTest.java b/src/test/java/StackArray/GenericStackTest.java index 0aacd92..c61b904 100644 --- a/src/test/java/StackArray/GenericStackTest.java +++ b/src/test/java/StackArray/GenericStackTest.java @@ -1,41 +1,41 @@ -//package StackArray; -// -//import org.junit.Assert; -//import org.junit.Test; -// -//public class GenericStackTest { -// @Test -// public void testPushingGrowsTheStack() throws Exception { -// // Given an empty stack -// GenericStack stack = new GenericStack<>(); -// -// // Assert that it is empty. -// Assert.assertEquals(true, stack.isEmpty()); -// // When we push something onto the stack -// stack.push("foobar"); -// // Then it shouldn't be empty -// Assert.assertEquals(false, stack.isEmpty()); -// } -// -// @Test -// public void testPushingAndPoppingOrder() throws Exception { -// // Given an empty stack -// GenericStack stack = new GenericStack<>(); -// // When we push two elements on it -// stack.push("foo"); -// stack.push("bar"); -// // Then we should see them returned in the correct order -// Assert.assertEquals("bar", stack.pop()); -// Assert.assertEquals("foo", stack.pop()); -// } -// -// @Test(expected = IndexOutOfBoundsException.class) -// public void testPopFirst() throws Exception { -// // Given an empty stack -// GenericStack stack = new GenericStack<>(); -// // When it's popped -// stack.pop(); -// // Then we should get an exception -// } -// -//} \ No newline at end of file +package StackArray; + +import org.junit.Assert; +import org.junit.Test; + +public class GenericStackTest { + @Test + public void testPushingGrowsTheStack() throws Exception { + // Given an empty stack + GenericStack stack = new GenericStack<>(); + + // Assert that it is empty. + Assert.assertEquals(true, stack.isEmpty()); + // When we push something onto the stack + stack.push("foobar"); + // Then it shouldn't be empty + Assert.assertEquals(false, stack.isEmpty()); + } + + @Test + public void testPushingAndPoppingOrder() throws Exception { + // Given an empty stack + GenericStack stack = new GenericStack<>(); + // When we push two elements on it + stack.push("foo"); + stack.push("bar"); + // Then we should see them returned in the correct order + Assert.assertEquals("bar", stack.pop()); + Assert.assertEquals("foo", stack.pop()); + } + + @Test(expected = IndexOutOfBoundsException.class) + public void testPopFirst() throws Exception { + // Given an empty stack + GenericStack stack = new GenericStack<>(); + // When it's popped + stack.pop(); + // Then we should get an exception + } + +} \ No newline at end of file From 8d89c1a2a7d1d5ff5c8da8a58e528a1c03304b80 Mon Sep 17 00:00:00 2001 From: Amy Gill Date: Mon, 12 Mar 2018 17:01:00 -0400 Subject: [PATCH 5/8] objectStack all tests passing --- src/main/java/StackArray/ObjectStack.java | 17 ++++ src/test/java/StackArray/ObjectStackTest.java | 78 +++++++++---------- 2 files changed, 56 insertions(+), 39 deletions(-) diff --git a/src/main/java/StackArray/ObjectStack.java b/src/main/java/StackArray/ObjectStack.java index 1124698..d541b94 100644 --- a/src/main/java/StackArray/ObjectStack.java +++ b/src/main/java/StackArray/ObjectStack.java @@ -1,5 +1,6 @@ package StackArray; +import java.util.ArrayList; import java.util.Arrays; /** @@ -11,6 +12,22 @@ public class ObjectStack { private Object[] elements; public ObjectStack() { + elements= new Object[0]; } + + public boolean isEmpty() { + return elements.length==0; + } + + public void push(E foobar) { + elements=Arrays.copyOf(elements,elements.length+1); + elements[elements.length-1] = foobar; + } + + public E pop() { + E lastElement = (E) elements[elements.length-1]; + elements= Arrays.copyOf(elements,elements.length-1); + return lastElement; + } } diff --git a/src/test/java/StackArray/ObjectStackTest.java b/src/test/java/StackArray/ObjectStackTest.java index 9ec9615..2576f1b 100644 --- a/src/test/java/StackArray/ObjectStackTest.java +++ b/src/test/java/StackArray/ObjectStackTest.java @@ -1,39 +1,39 @@ -//package StackArray; -// -//import org.junit.Assert; -//import org.junit.Test; -// -//public class ObjectStackTest { -// @Test -// public void testPushingGrowsTheStack() throws Exception { -// // Given an empty stack -// ObjectStack stack = new ObjectStack<>(); -// // Assert that it is empty. -// Assert.assertEquals(true, stack.isEmpty()); -// // When we push something onto the stack -// stack.push("foobar"); -// // Then it shouldn't be empty -// Assert.assertEquals(false, stack.isEmpty()); -// } -// -// @Test -// public void testPushingAndPoppingOrder() throws Exception { -// // Given an empty stack -// ObjectStack stack = new ObjectStack<>(); -// // When we push two elements on it -// stack.push("foo"); -// stack.push("bar"); -// // Then we should see them returned in the correct order -// Assert.assertEquals("bar", stack.pop()); -// Assert.assertEquals("foo", stack.pop()); -// } -// -// @Test(expected = IndexOutOfBoundsException.class) -// public void testPopFirst() throws Exception { -// // Given an empty stack -// ObjectStack stack = new ObjectStack<>(); -// // When it's popped -// stack.pop(); -// // Then we should get an exception -// } -//} \ No newline at end of file +package StackArray; + +import org.junit.Assert; +import org.junit.Test; + +public class ObjectStackTest { + @Test + public void testPushingGrowsTheStack() throws Exception { + // Given an empty stack + ObjectStack stack = new ObjectStack<>(); + // Assert that it is empty. + Assert.assertEquals(true, stack.isEmpty()); + // When we push something onto the stack + stack.push("foobar"); + // Then it shouldn't be empty + Assert.assertEquals(false, stack.isEmpty()); + } + + @Test + public void testPushingAndPoppingOrder() throws Exception { + // Given an empty stack + ObjectStack stack = new ObjectStack<>(); + // When we push two elements on it + stack.push("foo"); + stack.push("bar"); + // Then we should see them returned in the correct order + Assert.assertEquals("bar", stack.pop()); + Assert.assertEquals("foo", stack.pop()); + } + + @Test(expected = IndexOutOfBoundsException.class) + public void testPopFirst() throws Exception { + // Given an empty stack + ObjectStack stack = new ObjectStack<>(); + // When it's popped + stack.pop(); + // Then we should get an exception + } +} \ No newline at end of file From 309375dd0e3efb54abb18b51d23799713362407f Mon Sep 17 00:00:00 2001 From: Amy Gill Date: Mon, 12 Mar 2018 17:48:11 -0400 Subject: [PATCH 6/8] table tests passing --- src/main/java/Table/Table.java | 53 ++++++++++++++- src/test/java/Table/TableTest.java | 100 ++++++++++++++--------------- 2 files changed, 102 insertions(+), 51 deletions(-) diff --git a/src/main/java/Table/Table.java b/src/main/java/Table/Table.java index 5ccce23..24491cd 100644 --- a/src/main/java/Table/Table.java +++ b/src/main/java/Table/Table.java @@ -1,5 +1,6 @@ package Table; +import java.lang.annotation.ElementType; import java.util.ArrayList; /** @@ -10,8 +11,58 @@ * Void return on `remove`. */ public class Table { - private ArrayList entries; + private ArrayList entries; public Table() { + entries= new ArrayList<>(); } + +// public V get(K key){ +// +// for (Entry element: entries){ +// if (element.getKey().equals(key)){ +// return (V) element.getValue(); +// } +// } +// +// return null; +// +// } + + public V get(K key){ + + V ourLocalVariable = null; + + + for (Entry element: entries){ + if (element.getKey().equals(key)){ + ourLocalVariable =(V) element.getValue(); + } + } + + return ourLocalVariable; + + } + + public void put(K foo, V i){ + Entry ourEntry = new Entry(foo, i); + for (Entry element: entries){ + if (element.getKey().equals(ourEntry.getKey())){ + entries.set(entries.indexOf(element),ourEntry); + } + } + + entries.add(ourEntry); + + } + + public void remove(K foo){ + for (Entry element: entries){ + if (element.getKey().equals(foo)){ + entries.remove(element); + break; + } + } + } + } diff --git a/src/test/java/Table/TableTest.java b/src/test/java/Table/TableTest.java index 15ac19c..d1951e7 100644 --- a/src/test/java/Table/TableTest.java +++ b/src/test/java/Table/TableTest.java @@ -1,50 +1,50 @@ -//package Table; -// -//import org.junit.Assert; -//import org.junit.Test; -// -//public class TableTest { -// @Test -// public void testGetWithoutAnItemReturnsNull() throws Exception { -// // Given an empty table -// Table table = new Table(); -// // When we try and get an item then it returns null -// Assert.assertEquals(table.get("foo"), null); -// } -// -// @Test -// public void testPutAnItemReturnsAndDoesNotDelete() throws Exception { -// //Given an empty table -// Table table = new Table(); -// // When we put an item in it -// table.put("foo", 1); -// // Then we should be able to get it's value -// Assert.assertEquals(table.get("foo"), new Integer(1)); -// // And then we should be able to get it again as it wasn't removed -// Assert.assertEquals(table.get("foo"), new Integer(1)); -// } -// -// @Test -// public void testOverwritingAnItem() throws Exception { -// //Given an empty table -// Table table = new Table(); -// // When we put an item in it -// table.put("foo", 1); -// // And we put a new value with the same key -// table.put("foo", 2); -// // Then we should get back the new value -// Assert.assertEquals(table.get("foo"), new Integer(2)); -// } -// -// @Test -// public void testRemoveAnItem() throws Exception { -// //Given an empty table -// Table table = new Table(); -// // When we put an item in it -// table.put("foo", 1); -// // And we remove that item -// table.remove("foo"); -// // Then we should get back null for that balue -// Assert.assertEquals(table.get("foo"), null); -// } -//} \ No newline at end of file +package Table; + +import org.junit.Assert; +import org.junit.Test; + +public class TableTest { + @Test + public void testGetWithoutAnItemReturnsNull() throws Exception { + // Given an empty table + Table table = new Table(); + // When we try and get an item then it returns null + Assert.assertEquals(table.get("foo"), null); + } + + @Test + public void testPutAnItemReturnsAndDoesNotDelete() throws Exception { + //Given an empty table + Table table = new Table(); + // When we put an item in it + table.put("foo", 1); + // Then we should be able to get it's value + Assert.assertEquals(table.get("foo"), new Integer(1)); + // And then we should be able to get it again as it wasn't removed + Assert.assertEquals(table.get("foo"), new Integer(1)); + } + + @Test + public void testOverwritingAnItem() throws Exception { + //Given an empty table + Table table = new Table(); + // When we put an item in it + table.put("foo", 1); + // And we put a new value with the same key + table.put("foo", 2); + // Then we should get back the new value + Assert.assertEquals(table.get("foo"), new Integer(2)); + } + + @Test + public void testRemoveAnItem() throws Exception { + //Given an empty table + Table table = new Table(); + // When we put an item in it + table.put("foo", 1); + // And we remove that item + table.remove("foo"); + // Then we should get back null for that balue + Assert.assertEquals(null, table.get("foo")); + } +} \ No newline at end of file From fd54f06bd44ee1a56f9e862f95a4d19f4273f176 Mon Sep 17 00:00:00 2001 From: Amy Gill Date: Mon, 12 Mar 2018 17:52:54 -0400 Subject: [PATCH 7/8] tablenested complete --- src/main/java/TableNested/TableNested.java | 64 +++++++++++ .../java/TableNested/TableNestedTest.java | 100 +++++++++--------- 2 files changed, 114 insertions(+), 50 deletions(-) diff --git a/src/main/java/TableNested/TableNested.java b/src/main/java/TableNested/TableNested.java index 7e0dfdd..fac1c17 100644 --- a/src/main/java/TableNested/TableNested.java +++ b/src/main/java/TableNested/TableNested.java @@ -8,4 +8,68 @@ */ public class TableNested { + private ArrayList entries; + + public TableNested() { + entries= new ArrayList<>(); + } + + + public class Entry { + private K key; + private V value; + + public Entry(K key, V value) { + this.key = key; + this.value = value; + } + + public K getKey() { + return key; + } + + public V getValue() { + return value; + } + + } + + + public V get(K key){ + + V ourLocalVariable = null; + + + for (Entry element: entries){ + if (element.getKey().equals(key)){ + ourLocalVariable =(V) element.getValue(); + } + } + + return ourLocalVariable; + + } + + public void put(K foo, V i){ + Entry ourEntry = new Entry(foo, i); + for (Entry element: entries){ + if (element.getKey().equals(ourEntry.getKey())){ + entries.set(entries.indexOf(element),ourEntry); + } + } + + entries.add(ourEntry); + + } + + public void remove(K foo){ + for (Entry element: entries){ + if (element.getKey().equals(foo)){ + entries.remove(element); + break; + } + } + } + + } diff --git a/src/test/java/TableNested/TableNestedTest.java b/src/test/java/TableNested/TableNestedTest.java index 8432277..fdf12d5 100644 --- a/src/test/java/TableNested/TableNestedTest.java +++ b/src/test/java/TableNested/TableNestedTest.java @@ -1,50 +1,50 @@ -//package TableNested; -// -//import org.junit.Assert; -//import org.junit.Test; -// -//public class TableNestedTest { -// @Test -// public void testGetWithoutAnItemReturnsNull() throws Exception { -// // Given an empty table -// TableNested table = new TableNested(); -// // When we try and get an item then it returns null -// Assert.assertEquals(table.get("foo"), null); -// } -// -// @Test -// public void testPutAnItemReturnsAndDoesNotDelete() throws Exception { -// //Given an empty table -// TableNested table = new TableNested(); -// // When we put an item in it -// table.put("foo", 1); -// // Then we should be able to get it's value -// Assert.assertEquals(table.get("foo"), new Integer(1)); -// // And then we should be able to get it again as it wasn't removed -// Assert.assertEquals(table.get("foo"), new Integer(1)); -// } -// -// @Test -// public void testOverwritingAnItem() throws Exception { -// //Given an empty table -// TableNested table = new TableNested(); -// // When we put an item in it -// table.put("foo", 1); -// // And we put a new value with the same key -// table.put("foo", 2); -// // Then we should get back the new value -// Assert.assertEquals(table.get("foo"), new Integer(2)); -// } -// -// @Test -// public void testRemoveAnItem() throws Exception { -// //Given an empty table -// TableNested table = new TableNested(); -// // When we put an item in it -// table.put("foo", 1); -// // And we remove that item -// table.remove("foo"); -// // Then we should get back null for that balue -// Assert.assertEquals(table.get("foo"), null); -// } -//} \ No newline at end of file +package TableNested; + +import org.junit.Assert; +import org.junit.Test; + +public class TableNestedTest { + @Test + public void testGetWithoutAnItemReturnsNull() throws Exception { + // Given an empty table + TableNested table = new TableNested(); + // When we try and get an item then it returns null + Assert.assertEquals(table.get("foo"), null); + } + + @Test + public void testPutAnItemReturnsAndDoesNotDelete() throws Exception { + //Given an empty table + TableNested table = new TableNested(); + // When we put an item in it + table.put("foo", 1); + // Then we should be able to get it's value + Assert.assertEquals(table.get("foo"), new Integer(1)); + // And then we should be able to get it again as it wasn't removed + Assert.assertEquals(table.get("foo"), new Integer(1)); + } + + @Test + public void testOverwritingAnItem() throws Exception { + //Given an empty table + TableNested table = new TableNested(); + // When we put an item in it + table.put("foo", 1); + // And we put a new value with the same key + table.put("foo", 2); + // Then we should get back the new value + Assert.assertEquals(table.get("foo"), new Integer(2)); + } + + @Test + public void testRemoveAnItem() throws Exception { + //Given an empty table + TableNested table = new TableNested(); + // When we put an item in it + table.put("foo", 1); + // And we remove that item + table.remove("foo"); + // Then we should get back null for that balue + Assert.assertEquals(table.get("foo"), null); + } +} \ No newline at end of file From 98703de122474b15bc0ddd73f9bf95767db7e456 Mon Sep 17 00:00:00 2001 From: Amy Gill Date: Mon, 12 Mar 2018 19:22:31 -0400 Subject: [PATCH 8/8] simulation complete. all tests passing --- .../ArrayListCombiner/ArrayListCombiner.java | 14 ++ src/main/java/MapFunc/MapFunc.java | 10 ++ src/main/java/Pair/Arrays.java | 68 ++++++-- src/main/java/Pair/Pair.java | 35 ++++- .../ArrayListCombinerTest.java | 70 ++++----- src/test/java/MapFunc/MapFuncTest.java | 72 ++++----- src/test/java/Pair/ArraysTest.java | 148 +++++++++--------- src/test/java/Pair/PairTest.java | 64 ++++---- src/test/java/Swap/SwapTest.java | 30 ++-- 9 files changed, 302 insertions(+), 209 deletions(-) diff --git a/src/main/java/ArrayListCombiner/ArrayListCombiner.java b/src/main/java/ArrayListCombiner/ArrayListCombiner.java index d302cd2..faffcbe 100644 --- a/src/main/java/ArrayListCombiner/ArrayListCombiner.java +++ b/src/main/java/ArrayListCombiner/ArrayListCombiner.java @@ -1,5 +1,7 @@ package ArrayListCombiner; +import Table.Entry; + import java.util.ArrayList; /** @@ -9,4 +11,16 @@ * The second method should be called superCombiner and should use ? super E */ public class ArrayListCombiner { + + public static ArrayList extendCombiner(ArrayList firstArray, ArrayList secondArray){ + firstArray.addAll(secondArray); + return firstArray; + + } + + public static ArrayList superCombiner(ArrayList firstArray, ArrayList secondArray){ + firstArray.addAll(secondArray); + return firstArray; + + } } diff --git a/src/main/java/MapFunc/MapFunc.java b/src/main/java/MapFunc/MapFunc.java index ed4bf66..ba30ef6 100644 --- a/src/main/java/MapFunc/MapFunc.java +++ b/src/main/java/MapFunc/MapFunc.java @@ -9,4 +9,14 @@ */ public class MapFunc { + // in this case, T is input and R is output + public static ArrayList map(ArrayList myInput, Function myFunc){ + ArrayList output = new ArrayList<>(); + for (T element : myInput){ + output.add(myFunc.apply(element)); + } + return output; + + } + } diff --git a/src/main/java/Pair/Arrays.java b/src/main/java/Pair/Arrays.java index 502e04a..9906f97 100644 --- a/src/main/java/Pair/Arrays.java +++ b/src/main/java/Pair/Arrays.java @@ -1,16 +1,52 @@ -//package Pair; -// -//import java.util.ArrayList; -//import java.util.Collections; -// -///** -// * In here you must make firstLast, which will return a pair of the first element in the array list and the last -// * element in the arraylist. -// * You must also make a min method that returns the smallest item in the array list -// * A max method that returns the largest item in the arraylist -// * And a minmax method that returns a pair containing the largest and smallest items from the array list -// */ -//public class Arrays { -// public static <___> Pair firstLast(ArrayList<___> a) { -// } -//} +package Pair; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.Comparator; + +/** + * In here you must make firstLast, which will return a pair of the first element in the array list and the last + * element in the arraylist. + * You must also make a min method that returns the smallest item in the array list + * A max method that returns the largest item in the arraylist + * And a minmax method that returns a pair containing the largest and smallest items from the array list + */ +public class Arrays { + public static Pair firstLast(ArrayList arrayList) { + E firstItem = arrayList.get(0); + E lastItem = arrayList.get(arrayList.size()-1); + + Pair answer= new Pair<>(firstItem,lastItem); + + return answer; + + } + + public static E min (ArrayList arrayList) { + arrayList.sort(Comparator.naturalOrder()); + E minItem = arrayList.get(0); + + return minItem; + + } + + public static E max (ArrayList arrayList) { + arrayList.sort(Comparator.naturalOrder()); + E maxItem = arrayList.get(arrayList.size()-1); + + return maxItem; + + + } + + public static Pair minMax (ArrayList arrayList) { + arrayList.sort(Comparator.naturalOrder()); + + Pair answer = new Pair(arrayList.get(0), arrayList.get(arrayList.size()-1)); + + return answer; + + } + + +} diff --git a/src/main/java/Pair/Pair.java b/src/main/java/Pair/Pair.java index c4dd905..7cca62b 100644 --- a/src/main/java/Pair/Pair.java +++ b/src/main/java/Pair/Pair.java @@ -7,6 +7,39 @@ * min -> returns the minimum of the pair * max -> returns the maximum of the pair */ -public class Pair { +public class Pair { + + E firstVal; + E secondVal; + + public Pair(E firstVal, E secondVal){ + this.firstVal=firstVal; + this.secondVal=secondVal; + } + + public E getFirst(){ + return firstVal; + } + + public E getSecond(){ + return secondVal; + } + + public E min(){ + + E smallerOfTwo; + smallerOfTwo= firstVal.compareTo(secondVal) == 1 ? secondVal:firstVal; + + return smallerOfTwo; + } + + public E max(){ + + E largerOfTwo; + largerOfTwo= firstVal.compareTo(secondVal) == 1 ? firstVal:secondVal; + + return largerOfTwo; + + } } diff --git a/src/test/java/ArrayListCombiner/ArrayListCombinerTest.java b/src/test/java/ArrayListCombiner/ArrayListCombinerTest.java index 957a878..9e16484 100644 --- a/src/test/java/ArrayListCombiner/ArrayListCombinerTest.java +++ b/src/test/java/ArrayListCombiner/ArrayListCombinerTest.java @@ -9,40 +9,40 @@ import java.util.ArrayList; public class ArrayListCombinerTest { -// Employee foo = new Employee("FOO", 100); -// Manager bar = new Manager("BAR", 100); -// @Test -// public void testExtendCombiner() throws Exception { -// // Given an array list with employees -// ArrayList first = new ArrayList<>(); -// first.add(foo); -// // An an array list with managers -// ArrayList second = new ArrayList<>(); -// second.add(bar); -// // When I combine them -// ArrayListCombiner.extendCombiner(first, second); -// // Then I should get an arrayList with both -// ArrayList expected = new ArrayList<>(); -// expected.add(foo); -// expected.add(bar); -// Assert.assertEquals(expected, first); -// } -// -// @Test -// public void testSuperCombiner() throws Exception { -// // Given an array list with employees -// ArrayList first = new ArrayList<>(); -// first.add(foo); -// // An an array list with managers -// ArrayList second = new ArrayList<>(); -// second.add(bar); -// // When I combine them -// ArrayListCombiner.superCombiner(first, second); -// // Then I should get an arrayList with both -// ArrayList expected = new ArrayList<>(); -// expected.add(foo); -// expected.add(bar); -// Assert.assertEquals(expected, first); -// } + Employee foo = new Employee("FOO", 100); + Manager bar = new Manager("BAR", 100); + @Test + public void testExtendCombiner() throws Exception { + // Given an array list with employees + ArrayList first = new ArrayList<>(); + first.add(foo); + // An an array list with managers + ArrayList second = new ArrayList<>(); + second.add(bar); + // When I combine them + ArrayListCombiner.extendCombiner(first, second); + // Then I should get an arrayList with both + ArrayList expected = new ArrayList<>(); + expected.add(foo); + expected.add(bar); + Assert.assertEquals(expected, first); + } + + @Test + public void testSuperCombiner() throws Exception { + // Given an array list with employees + ArrayList first = new ArrayList<>(); + first.add(foo); + // An an array list with managers + ArrayList second = new ArrayList<>(); + second.add(bar); + // When I combine them + ArrayListCombiner.superCombiner(first, second); + // Then I should get an arrayList with both + ArrayList expected = new ArrayList<>(); + expected.add(foo); + expected.add(bar); + Assert.assertEquals(expected, first); + } } \ No newline at end of file diff --git a/src/test/java/MapFunc/MapFuncTest.java b/src/test/java/MapFunc/MapFuncTest.java index 3c7534f..a3fdf58 100644 --- a/src/test/java/MapFunc/MapFuncTest.java +++ b/src/test/java/MapFunc/MapFuncTest.java @@ -1,36 +1,36 @@ -//package MapFunc; -// -//import MapFunc.MapFunc; -//import org.junit.Test; -// -//import java.util.ArrayList; -//import org.junit.Assert; -// -//public class MapFuncTest { -// @Test -// public void testSingleTypeMap() throws Exception { -// // Given an integer array list -// ArrayList intList = new ArrayList<>(); -// intList.add(1); -// intList.add(2); -// // When it's mapped with a function to double the value -// ArrayList mappedList = MapFunc.map(intList, num -> num*2); -// // Then all the values are doubled -// Assert.assertEquals(new Integer(2), mappedList.get(0)); -// Assert.assertEquals(new Integer(4), mappedList.get(1)); -// } -// -// @Test -// public void testMultipleTypeMap() throws Exception { -// // Given an integer array list -// ArrayList intList = new ArrayList<>(); -// intList.add(1); -// intList.add(2); -// // When it's mapped with to string -// ArrayList mappedList = MapFunc.map(intList, num -> num.toString()); -// // Then all the values are doubled -// Assert.assertEquals("1", mappedList.get(0)); -// Assert.assertEquals("2", mappedList.get(1)); -// } -// -//} \ No newline at end of file +package MapFunc; + +import MapFunc.MapFunc; +import org.junit.Test; + +import java.util.ArrayList; +import org.junit.Assert; + +public class MapFuncTest { + @Test + public void testSingleTypeMap() throws Exception { + // Given an integer array list + ArrayList intList = new ArrayList<>(); + intList.add(1); + intList.add(2); + // When it's mapped with a function to double the value + ArrayList mappedList = MapFunc.map(intList, num -> num*2); + // Then all the values are doubled + Assert.assertEquals(new Integer(2), mappedList.get(0)); + Assert.assertEquals(new Integer(4), mappedList.get(1)); + } + + @Test + public void testMultipleTypeMap() throws Exception { + // Given an integer array list + ArrayList intList = new ArrayList<>(); + intList.add(1); + intList.add(2); + // When it's mapped with to string + ArrayList mappedList = MapFunc.map(intList, num -> num.toString()); + // Then all the values are doubled + Assert.assertEquals("1", mappedList.get(0)); + Assert.assertEquals("2", mappedList.get(1)); + } + +} \ No newline at end of file diff --git a/src/test/java/Pair/ArraysTest.java b/src/test/java/Pair/ArraysTest.java index 4d32e23..0d51970 100644 --- a/src/test/java/Pair/ArraysTest.java +++ b/src/test/java/Pair/ArraysTest.java @@ -1,74 +1,74 @@ -//package Pair; -// -//import org.junit.Assert; -//import org.junit.Test; -// -//import java.util.ArrayList; -// -//public class ArraysTest { -// @Test -// public void firstLast() throws Exception { -// // Given an ArrayList of Integers -// ArrayList al = new ArrayList<>(); -// al.add(1); -// al.add(5); -// al.add(3); -// al.add(4); -// al.add(2); -// al.add(0); -// al.add(1000); -// // When firstLast is called -// Pair result = Arrays.firstLast(al); -// // Then it should return the first and last items -// Assert.assertEquals(new Integer(1), result.getFirst()); -// Assert.assertEquals(new Integer(1000), result.getSecond()); -// } -// -// @Test -// public void testMin() throws Exception { -// // Given an ArrayList of Integers -// ArrayList al = new ArrayList<>(); -// al.add(1); -// al.add(5); -// al.add(3); -// al.add(4); -// al.add(2); -// al.add(0); -// al.add(1000); -// // When min is called assert that it gets the smallest item -// Assert.assertEquals(new Integer(0), Arrays.min(al)); -// } -// -// @Test -// public void testMax() throws Exception { -// // Given an ArrayList of Integers -// ArrayList al = new ArrayList<>(); -// al.add(1); -// al.add(5); -// al.add(3); -// al.add(4); -// al.add(2); -// al.add(0); -// al.add(1000); -// // When min is called assert that it gets the largest item -// Assert.assertEquals(new Integer(1000), Arrays.max(al)); -// } -// -// @Test -// public void testMinMax() throws Exception { -// // Given an ArrayList of Integers -// ArrayList al = new ArrayList<>(); -// al.add(1); -// al.add(5); -// al.add(3); -// al.add(4); -// al.add(2); -// al.add(0); -// al.add(1000); -// // When minMax is called -// Pair result = Arrays.minMax(al); -// // Then it should return the first and last items -// Assert.assertEquals(new Integer(0), result.min()); -// Assert.assertEquals(new Integer(1000), result.max()); -// } -//} +package Pair; + +import org.junit.Assert; +import org.junit.Test; + +import java.util.ArrayList; + +public class ArraysTest { + @Test + public void firstLast() throws Exception { + // Given an ArrayList of Integers + ArrayList al = new ArrayList<>(); + al.add(1); + al.add(5); + al.add(3); + al.add(4); + al.add(2); + al.add(0); + al.add(1000); + // When firstLast is called + Pair result = Arrays.firstLast(al); + // Then it should return the first and last items + Assert.assertEquals(new Integer(1), result.getFirst()); + Assert.assertEquals(new Integer(1000), result.getSecond()); + } + + @Test + public void testMin() throws Exception { + // Given an ArrayList of Integers + ArrayList al = new ArrayList<>(); + al.add(1); + al.add(5); + al.add(3); + al.add(4); + al.add(2); + al.add(0); + al.add(1000); + // When min is called assert that it gets the smallest item + Assert.assertEquals(new Integer(0), Arrays.min(al)); + } + + @Test + public void testMax() throws Exception { + // Given an ArrayList of Integers + ArrayList al = new ArrayList<>(); + al.add(1); + al.add(5); + al.add(3); + al.add(4); + al.add(2); + al.add(0); + al.add(1000); + // When min is called assert that it gets the largest item + Assert.assertEquals(new Integer(1000), Arrays.max(al)); + } + + @Test + public void testMinMax() throws Exception { + // Given an ArrayList of Integers + ArrayList al = new ArrayList<>(); + al.add(1); + al.add(5); + al.add(3); + al.add(4); + al.add(2); + al.add(0); + al.add(1000); + // When minMax is called + Pair result = Arrays.minMax(al); + // Then it should return the first and last items + Assert.assertEquals(new Integer(0), result.min()); + Assert.assertEquals(new Integer(1000), result.max()); + } +} diff --git a/src/test/java/Pair/PairTest.java b/src/test/java/Pair/PairTest.java index d616178..baf2071 100644 --- a/src/test/java/Pair/PairTest.java +++ b/src/test/java/Pair/PairTest.java @@ -1,32 +1,32 @@ -//package Pair; -// -//import org.junit.Test; -//import org.junit.Assert; -// -//public class PairTest { -// -// @Test -// public void testGetters() throws Exception { -// // Given a pair with "Foo" and "Bar" -// Pair p = new Pair("Foo", "Bar"); -// // When getFirst and getSecond are called, they should be returned. -// Assert.assertEquals("Foo", p.getFirst()); -// Assert.assertEquals("Bar", p.getSecond()); -// } -// -// @Test -// public void testMin() throws Exception { -// // Given a pair with two values -// Pair p = new Pair(1.23, 2.34); -// // When p.min() is called, the smallest should be returned. -// Assert.assertEquals(new Double(1.23), p.min()); -// } -// -// @Test -// public void testMax() throws Exception { -// // Given a pair with two values -// Pair p = new Pair(1.23, 2.34); -// // When p.max() is called, the largest should be returned. -// Assert.assertEquals(new Double(2.34), p.max()); -// } -//} \ No newline at end of file +package Pair; + +import org.junit.Test; +import org.junit.Assert; + +public class PairTest { + + @Test + public void testGetters() throws Exception { + // Given a pair with "Foo" and "Bar" + Pair p = new Pair("Foo", "Bar"); + // When getFirst and getSecond are called, they should be returned. + Assert.assertEquals("Foo", p.getFirst()); + Assert.assertEquals("Bar", p.getSecond()); + } + + @Test + public void testMin() throws Exception { + // Given a pair with two values + Pair p = new Pair(1.23, 2.34); + // When p.min() is called, the smallest should be returned. + Assert.assertEquals(new Double(1.23), p.min()); + } + + @Test + public void testMax() throws Exception { + // Given a pair with two values + Pair p = new Pair(1.23, 2.34); + // When p.max() is called, the largest should be returned. + Assert.assertEquals(new Double(2.34), p.max()); + } +} \ No newline at end of file diff --git a/src/test/java/Swap/SwapTest.java b/src/test/java/Swap/SwapTest.java index 2583b9d..1ff0303 100644 --- a/src/test/java/Swap/SwapTest.java +++ b/src/test/java/Swap/SwapTest.java @@ -1,16 +1,16 @@ package Swap; -// -//import org.junit.Assert; -//import org.junit.Test; -// -///** -// * Get the tests passing. -// */ -//public class SwapTest { -// @Test -// public void testSwap() throws Exception { -// Double[] result = Swap.swap(0,1, 1.5, 2,3); -// Double[] expected = {2.0, 1.5, 3.0}; -// Assert.assertArrayEquals(expected, result); -// } -//} \ No newline at end of file + +import org.junit.Assert; +import org.junit.Test; + +/** + * Get the tests passing. + */ +public class SwapTest { + @Test + public void testSwap() throws Exception { + Double[] result = Swap.swap(0,1, 1.5, 2.0,3.0); + Double[] expected = {2.0, 1.5, 3.0}; + Assert.assertArrayEquals(expected, result); + } +} \ No newline at end of file