Java Classes Implementation in Java Assignment Solution

June 29, 2024

Alex Thompson

🇺🇸 United States

Java

Alex Thompson is a skilled Java Assignment Expert with 8 years of experience. He completed his Master's degree at Stanford University, USA.

Hire Now

Java

Key Topics

Instructions
Requirements and Specifications

Submit Your Java Assignment

Get a FREE Quote

Tip of the day

Familiarize yourself with OCaml's pattern matching; it simplifies handling recursive data structures like lists and trees, making your code concise and easier to debug.

News

In 2024, Girls Who Code introduced a Data Science + AI track in their free summer programs for high school students, fostering skills in cybersecurity and creative coding

Instructions

Objective

Write a java assignment program to implement java classes.

Requirements and Specifications

Source Code

TEST EFFICIENCY
import java.util.Random;
import edu.uwm.cs351.SortedSequence;
import junit.framework.TestCase;
public class TestEfficiency extends TestCase {
 private SortedSequencess;
 private static final int POWER = 21; // 1 million entries
 private static final int TESTS = 100_000;
 protected void setUp() throws Exception {
  super.setUp();
  new Random();
  try {
   assert ss.size() == TESTS : "cannot run test with assertions enabled";
  } catch (NullPointerException ex) {
   System.err.println("You need to turn off assertions.");
   System.err.println("Go to Run Configurations > TestEfficiency and go to the Arguments tab");
   System.err.println("and remove -ea from the VM Arguments box.");
   throw new IllegalStateException("Cannot run test with assertions enabled");
  }
  ss = new SortedSequence<>((i1,i2) -> i1 - i2);
  int max = (1 << (POWER)); // 2^(POWER) = 2 million
  for (int power = POWER; power > 1; --power) {
   int incr = 1 << power;
   for (int i=1 << (power-1); i < max; i += incr) {
    ss.add(i);
   }
  }
 }
 @Override
 protected void tearDown() throws Exception {
  ss = null;
  super.tearDown();
 }
 public void testSize() {
  for (int i=0; i < TESTS; ++i) {
   assertEquals((1<<(POWER-1))-1,ss.size());
  }
 }
 public void testGet() {
  ss.start();
  int max = 1 << POWER;
  for (int i=2; i < max; i += 2) {
   Integer elem = ss.getCurrent();
   assertEquals(i/10, elem/10);
   ss.advance();
  }
 }
 public void testRemove() {
  int max = (1 << (POWER)); // 2^(POWER) = 2 million
  int power = 4;
  int incr = 1 << power;
  ss.start();
  for (int i=1 << (power-1); i < max; i += incr) {
   while (ss.getCurrent().intValue() != i) {
    assertTrue(ss.getCurrent()/10 <= i/10);
    ss.advance();
   }
   ss.removeCurrent();
  }
  int removed = 1<<(POWER-power);
  assertEquals(max/2 - 1 - removed, ss.size());
 }
 public void testClone() {
  int pow = POWER/2;
  int num = 1 << pow;
  while (pow > 1) {
   --pow;
   num += (1 << pow);
   --pow;
   num -= (1 << pow);
  }
  System.out.println("num = " + num);
  ss.add(num-1);
  ss.removeCurrent();
  assertEquals(num+1, ss.getCurrent().intValue());
  SortedSequencec = ss.clone();
  assertEquals(num+1, c.getCurrent().intValue());
  c.removeCurrent();
  assertEquals(num+1, ss.getCurrent().intValue());
  assertEquals(num+3, c.getCurrent().intValue());
  ss.advance();
  assertEquals(num+3, ss.getCurrent().intValue());
  assertEquals(num+3, c.getCurrent().intValue());
  ss.advance();
  assertEquals(num+5, ss.getCurrent().intValue());
  assertEquals(num+3, c.getCurrent().intValue());
  ss.advance();
  assertEquals(num+7, ss.getCurrent().intValue());
  assertEquals(num+3, c.getCurrent().intValue());
 }
}
TEST INTERNALS
import edu.uwm.cs351.SortedSequence;
public class TestInternals extends SortedSequence.TestInternals {
 /// Locked tests:
 @SuppressWarnings("unused")
 public void test() {
  // Which single-character strings can fit in the given
  // spots in this tree? (Using case-insensitive ordering)
  // C
  // / \
  // A e
  // \ /
  // # $
  // Write your answer as a sorted set without spaces
  // in which UPPERCASE letters precede lowercase letters.
  // For example: {K,k,L}, not {k,K,L} or {K, k, L } or {K,L,k}
  String answer1 = Ts(2034396360); // what keys at #
  String answer2 = Ts(577043295); // what keys at $
  testCont(false);
 }
 @SuppressWarnings("unused")
 private void testCont(boolean ignored) {
  // We are checking the "immediate greater ancestor" property
  // for nodes in this tree:
  // M
  // / \
  // / \
  // G S
  // / \ / \
  // D K P W
  // / \ \ \ \
  // A F L Q Y
  // Give the letter or "none"
  String answer1 = Ts(960628806); // imm. gr. ancestor of A ?
  String answer2 = Ts(1533686037); // imm. gr. ancestor of K ?
  String answer3 = Ts(1529894885); // imm. gr. ancestor of Q ?
  String answer4 = Ts(1790270167); // imm. gr. ancestor of Y ?
  testCont2(false);
 }
 @SuppressWarnings("unused")
 private void testCont2(boolean ignored) {
  // What are the valid cursor stacks for this tree?
  // M
  // / \
  // / \
  // G S
  // / \ / \
  // D K P W
  // / \ \ \ \
  // A F L Q Y
  // Write the stack with square brackets, commas, with the top to the right
  // but without spaces: e.g. [M,G,F] (when "F" is current)
  String answer1 = Ts(1039507205); // the stack after we call start() ("A" is current").
  String answer2 = Ts(1892415530); // The stack after we next call advance() ("D" is current").
  String answer3 = Ts(1308770658); // The stack when "L" is current
  String answer4 = Ts(395215552); // The stack when "Q" is current
 }
}
TEST SORTED SEQUENCE
import edu.uwm.cs.junit.LockedTestCase;
import edu.uwm.cs351.SortedSequence;
public class TestSortedSequence extends LockedTestCase {
 Integer b1 = 100;
 Integer b2 = 50;
 Integer b3 = 33;
 Integer b4 = 25;
 Integer b5 = 20;
 SortedSequences, se;
 SortedSequencess;
 @Override
 protected void setUp() {
  s = new SortedSequence((i1,i2) -> i2 - i1);
  se = new SortedSequence((i1,i2) -> i1 - i2);
  ss = new SortedSequence(String.CASE_INSENSITIVE_ORDER);
  try {
   assert 1/(b1-100) == 42 : "OK";
   System.err.println("Assertions must be enabled to use this test suite.");
   System.err.println("In Eclipse: add -ea in the VM Arguments box under Run>Run Configurations>Arguments");
   assertFalse("Assertions must be -ea enabled in the Run Configuration>Arguments>VM Arguments",true);
  } catch (ArithmeticException ex) {
   return;
  }
 }
 protected void assertException(ClassexcClass, Runnable f) {
  try {
   f.run();
   assertFalse("Should have thrown an exception, not returned ",true);
  } catch (RuntimeException ex) {
   if (!excClass.isInstance(ex)) {
    assertFalse("Wrong kind of exception thrown: "+ ex.getClass().getSimpleName(),true);
   }
  }
 }
 //// Locked Tests
 public void test() {
  // "ss" is sorted case insensitive (so "a" and "A" are sorted together, before "b" and "B").
  ss.add("Foo");
  ss.add("FOO");
  ss.add("foo");
  ss.add("fu");
  ss.add("bar");
  ss.start();
  assertEquals(Ts(540777888), ss.getCurrent());
  ss.advance();
  assertEquals(Ts(841015913), ss.getCurrent());
  ss.add("BAR");
  assertEquals(Ts(689167294), ss.getCurrent());
  ss.advance();
  assertEquals(Ts(1452336162), ss.getCurrent());
  testCont(false);
 }
 private void testCont(boolean ignored) {
  // ss is sorted case-insensitive
  // ss = [bar, BAR, *Foo, FOO, foo, fu] ("Foo" is current)
  ss.removeCurrent();
  assertEquals(Ti(917957413), ss.size());
  assertEquals(Ts(359804329), ss.getCurrent());
  ss.add("Foo");
  assertEquals(Ts(817754356), ss.getCurrent());
  ss.advance();
  assertEquals(Ts(815169093), ss.getCurrent());
 }
 //// Numbered tests
 /// test0N: simple tests on the empty sequence
 public void test00() {
  assertEquals(0,s.size());
 }
 public void test01() {
  assertFalse(s.isCurrent());
 }
 public void test02() {
  s.start(); // doesn't crash
 }
 public void test03() {
  assertException(IllegalStateException.class,() -> s.getCurrent());
 }
 public void test04() {
  assertException(IllegalStateException.class, () -> s.advance());
 }
 public void test05() {
  s.start();
  assertFalse(s.isCurrent());
 }
 public void test06() {
  assertEquals(0,s.size());
 }
 /// test1N: tests of a single element sequence
 public void test10() {
  s.add(b1);
  assertEquals(1,s.size());
 }
 public void test11() {
  s.add(b2);
  assertTrue(s.isCurrent());
 }
 public void test12() {
  s.add(b3);
  assertSame(b3,s.getCurrent());
 }
 public void test13() {
  s.add(b4);
  s.start();
  assertSame(b4,s.getCurrent());
 }
 public void test14() {
  s.add(b5);
  s.advance();
  assertFalse(s.isCurrent());
 }
 public void test15() {
  s.add(b5);
  s.advance();
  s.start();
  assertTrue(s.isCurrent());
 }
 public void test16() {
  assertException(NullPointerException.class, ()-> s.add(null));
  assertEquals(0,s.size());
 }
 public void test19() {
  s.add(b1);
  assertEquals(1,s.size());
  assertTrue(s.isCurrent());
  assertSame(b1,s.getCurrent());
 }
 /// test2N: tests of two element sequences
 public void test20() {
  s.add(b1);
  s.add(b2);
  assertEquals(2,s.size());
 }
 public void test21() {
  s.add(b3);
  s.add(b4);
  assertTrue(s.isCurrent());
 }
 public void test22() {
  s.add(b1);
  s.add(b2);
  assertSame(b2,s.getCurrent());
 }
 public void test23() {
  s.add(b1);
  s.add(b2);
  s.advance();
  assertFalse(s.isCurrent());
 }
 public void test24() {
  s.add(b4);
  s.add(b5);
  s.start();
  assertTrue(s.isCurrent());
  assertEquals(2,s.size());
  assertEquals(b4,s.getCurrent());
 }
 public void test25() {
  s.add(b2);
  s.add(b5);
  s.start();
  s.advance();
  s.start();
  assertTrue(s.isCurrent());
  assertEquals(2,s.size());
  assertEquals(b2,s.getCurrent());
 }
 public void test26() {
  s.add(b1);
  s.advance();
  s.add(b2);
  assertTrue(s.isCurrent());
  assertSame(b2,s.getCurrent());
 }
 public void test27() {
  s.add(b3);
  s.advance();
  s.add(b4);
  assertEquals(2,s.size());
  assertTrue(s.isCurrent());
  assertSame(b4,s.getCurrent());
 }
 public void test28() {
  s.add(b1);
  assertException(NullPointerException.class, () -> s.add(null));
  assertEquals(1,s.size());
 }
 /// test3N: tests of three or more element sequences
 public void test30() {
  s.add(b1);
  s.add(b2);
  s.add(b3);
  assertEquals(3,s.size());
  assertSame(b3,s.getCurrent());
  s.advance();
  assertFalse(s.isCurrent());
  s.start();
  assertSame(b1,s.getCurrent());
  s.advance();
  assertSame(b2,s.getCurrent());
  s.advance();
  assertSame(b3,s.getCurrent());
 }
 public void test31() {
  s.add(b4);
  s.add(b5);
  s.advance();
  s.add(b1);
  assertSame(b1,s.getCurrent());
  s.advance();
  assertEquals(3,s.size());
  assertSame(b4,s.getCurrent());
  s.advance();
  assertSame(b5,s.getCurrent());
  s.advance();
  assertFalse(s.isCurrent());
 }
 public void test32() {
  s.add(b2);
  s.add(b4);
  s.start();
  s.add(b3);
  assertSame(b3,s.getCurrent());
  s.advance();
  assertSame(b4,s.getCurrent());
  s.advance();
  assertFalse(s.isCurrent());
  s.start();
  assertSame(b2,s.getCurrent());
  assertEquals(3,s.size());
 }
 public void test33() {
  s.add(b1);
  assertException(NullPointerException.class, () -> s.add(null));
  s.add(b2);
  assertSame(b2,s.getCurrent());
  s.start();
  assertSame(b1,s.getCurrent());
  s.advance();
  assertTrue(s.isCurrent());
  assertSame(b2,s.getCurrent());
 }
 public void test34() {
  s.add(b4);
  s.add(b5);
  s.advance();
  s.add(b3);
  assertSame(b3, s.getCurrent());
  assertEquals(3,s.size());
  s.advance();
  assertSame(b4,s.getCurrent());
 }
 public void test35() {
  s.add(b1);
  s.add(b2);
  s.add(b3);
  s.start();
  s.add(b4);
  assertSame(b4,s.getCurrent());
  s.advance();
  assertException(IllegalStateException.class,() -> s.getCurrent() );
  s.start();
  assertSame(b1,s.getCurrent());
  s.advance();
  assertSame(b2,s.getCurrent());
  s.advance();
  assertSame(b3,s.getCurrent());
 }
 public void test36() {
  s.add(b5);
  s.add(b4);
  s.add(b3);
  s.start();
  s.advance();
  s.add(b2);
  assertEquals(b2,s.getCurrent());
  assertEquals(4,s.size());
  s.advance();
 }
 public void test37() {
  s.add(b1);
  s.advance();
  s.add(b2);
  s.advance();
  s.add(b3);
  s.advance();
  s.add(b4);
  s.advance();
  s.add(b5);
  s.start();
  assertSame(b1,s.getCurrent());
  s.advance();
  s.advance();
  assertSame(b3,s.getCurrent());
  s.advance();
  s.advance();
  s.advance();
  assertFalse(s.isCurrent());
  assertException(IllegalStateException.class,() -> s.advance() );
 }
 public void test38() {
  s.add(b1);
  s.add(b2);
  s.add(b3);
  s.add(b4);
  s.add(b5);
  s.add(b5);
  s.add(b4);
  s.add(b3);
  s.add(b2);
  s.add(b1);
  s.add(b1);
  s.add(b2);
  s.add(b3);
  s.add(b4);
  s.add(b5);
  assertEquals(15,s.size());
  s.start();
  assertSame(b1,s.getCurrent()); s.advance();
  assertSame(b1,s.getCurrent()); s.advance();
  assertSame(b1,s.getCurrent()); s.advance();
  assertSame(b2,s.getCurrent()); s.advance();
  assertSame(b2,s.getCurrent()); s.advance();
  assertSame(b2,s.getCurrent()); s.advance();
  assertSame(b3,s.getCurrent()); s.advance();
  assertSame(b3,s.getCurrent()); s.advance();
  assertSame(b3,s.getCurrent()); s.advance();
  assertSame(b4,s.getCurrent()); s.advance();
  assertSame(b4,s.getCurrent()); s.advance();
  assertSame(b4,s.getCurrent()); s.advance();
  assertSame(b5,s.getCurrent()); s.advance();
  assertSame(b5,s.getCurrent()); s.advance();
  assertSame(b5,s.getCurrent()); s.advance();
  assertFalse(s.isCurrent());
 }
 public void test39() {
  for (int i=0; i < 39; ++i) {
   s.add(i);
  }
  assertEquals(39,s.size());
  s.start();
  for (int i=0; i < 39; ++i) {
   assertTrue(s.isCurrent());
   assertEquals(38-i,s.getCurrent().intValue());
   s.advance();
  }
  assertFalse(s.isCurrent());
 }
 /// test4N: tests of removeCurrent
 public void test40() {
  s.add(b1);
  s.removeCurrent();
  assertFalse(s.isCurrent());
 }
 public void test41() {
  s.add(b2);
  s.removeCurrent();
  assertEquals(0,s.size());
 }
 public void test42() {
  s.add(b3);
  s.add(b4);
  s.removeCurrent();
  assertFalse(s.isCurrent());
  assertEquals(1,s.size());
  s.start();
  assertSame(b3,s.getCurrent());
 }
 public void test43() {
  s.add(b4);
  s.add(b3);
  s.start();
  s.removeCurrent();
  assertTrue(s.isCurrent());
  assertSame(b4,s.getCurrent());
 }
 public void test44() {
  s.add(b4);
  s.add(b5);
  s.start();
  s.removeCurrent();
  assertTrue(s.isCurrent());
  assertSame(b5,s.getCurrent());
 }
 public void test45() {
  s.add(b4);
  s.add(b3);
  s.add(b5);
  s.start();
  s.advance();
  s.removeCurrent();
  assertSame(b5,s.getCurrent());
  s.advance();
  assertFalse(s.isCurrent());
  assertEquals(2,s.size());
  s.start();
  assertSame(b3,s.getCurrent());
 }
 public void test46() {
  s.add(b4);
  s.add(b5);
  s.add(b1);
  s.removeCurrent();
  assertEquals(2,s.size());
  assertSame(b4,s.getCurrent()); s.advance();
  assertSame(b5,s.getCurrent()); s.advance();
  assertFalse(s.isCurrent());
 }
 public void test47() {
  s.add(b1);
  s.add(b2);
  s.add(b3);
  s.add(b4);
  s.add(b5);
  s.start();
  assertSame(b1,s.getCurrent()); s.advance();
  assertSame(b2,s.getCurrent());
  s.removeCurrent();
  assertSame(b3,s.getCurrent()); s.advance();
  assertSame(b4,s.getCurrent());
  s.removeCurrent();
  assertSame(b5,s.getCurrent()); s.advance();
  assertFalse(s.isCurrent());
  s.start();
  assertSame(b1,s.getCurrent()); s.advance();
  assertSame(b3,s.getCurrent()); s.advance();
  assertSame(b5,s.getCurrent()); s.advance();
  assertFalse(s.isCurrent());
 }
 public void test48() {
  s.add(b1);
  s.add(b2);
  s.add(b3);
  s.add(b4);
  s.add(b5);
  s.start();
  assertSame(b1,s.getCurrent()); s.removeCurrent();
  assertSame(b2,s.getCurrent()); s.advance();
  assertSame(b3,s.getCurrent()); s.removeCurrent();
  assertSame(b4,s.getCurrent()); s.advance();
  assertSame(b5,s.getCurrent()); s.removeCurrent();
  assertFalse(s.isCurrent());
  s.start();
  assertSame(b2,s.getCurrent()); s.advance();
  assertSame(b4,s.getCurrent()); s.advance();
  assertFalse(s.isCurrent());
 }
 public void test49() {
  for (int i=0; i < 49; ++i) {
   s.add(i);
  }
  s.start();
  for (int i=0; i < 49; ++i) {
   assertEquals(48-i,s.getCurrent().intValue());
   if ((i%2) == 0) s.removeCurrent();
   else s.advance();
  }
  s.start();
  for (int i=0; i < 24; ++i) {
   assertEquals(47-i*2,s.getCurrent().intValue());
   s.removeCurrent();
  }
  assertEquals(0,s.size());
 }
 /// test5N: errors with removeCurrent
 public void test50() {
  assertException(IllegalStateException.class, () -> s.removeCurrent());
 }
 public void test51() {
  s.add(b1);
  s.advance();
  assertException(IllegalStateException.class, () -> s.removeCurrent());
 }
 public void test52() {
  s.add(b1);
  s.removeCurrent();
  assertException(IllegalStateException.class, () -> s.removeCurrent());
 }
 public void test53() {
  s.add(b1);
  s.add(b2);
  s.removeCurrent();
  assertException(IllegalStateException.class, () -> s.removeCurrent());
 }
 public void test54() {
  s.add(b1);
  s.add(b2);
  s.add(b3);
  s.add(b4);
  s.add(b5);
  s.advance();
  assertException(IllegalStateException.class, () -> s.removeCurrent());
 }
 public void test55() {
  s.add(b5);
  s.advance();
  assertException(IllegalStateException.class, () -> s.removeCurrent());
  s.add(b4);
  s.advance();
  s.advance();
  assertException(IllegalStateException.class, () -> s.removeCurrent());
  s.add(b3);
  s.advance();
  s.advance();
  s.advance();
  assertException(IllegalStateException.class, () -> s.removeCurrent());
  s.add(b2);
  s.advance();
  s.advance();
  s.advance();
  s.advance();
  assertException(IllegalStateException.class, () -> s.removeCurrent());
  s.add(b1);
  assertEquals(5,s.size());
  assertSame(b1,s.getCurrent()); s.advance();
  assertSame(b2,s.getCurrent()); s.advance();
  assertSame(b3,s.getCurrent()); s.advance();
  assertSame(b4,s.getCurrent()); s.advance();
  assertSame(b5,s.getCurrent()); s.advance();
  assertFalse(s.isCurrent());
 }
 /// test6X: tests with distinguished equivalent elements
 public void test60() {
  ss.add("six");
  ss.add("Six");
  ss.add("Sixty");
  ss.add("SIX");
  assertEquals("SIX", ss.getCurrent());
  ss.advance();
  assertEquals("Sixty", ss.getCurrent());
  ss.advance();
  assertException(IllegalStateException.class, () -> ss.getCurrent());
 }
 public void test61() {
  ss.add("six");
  ss.add("SIX");
  ss.add("six");
  ss.start();
  assertEquals("six", ss.getCurrent());
  ss.advance();
  assertEquals("SIX", ss.getCurrent());
  ss.advance();
  assertEquals("six", ss.getCurrent());
 }
 /// test7X: tests of remove of equivalent elements
 public void test70() {
  ss.add("seven");
  ss.add("Seven");
  ss.removeCurrent();
  assertEquals(1, ss.size());
  assertFalse(ss.isCurrent());
  ss.start();
  assertEquals("seven", ss.getCurrent());
  ss.advance();
  assertFalse(ss.isCurrent());
 }
 public void test71() {
  ss.add("Seven");
  ss.add("seven");
  ss.start();
  ss.removeCurrent();
  assertEquals(1, ss.size());
  assertEquals("seven", ss.getCurrent());
 }
 public void test72() {
  ss.add("seven");
  ss.add("seventy");
  ss.add("SEVEN");
  ss.removeCurrent();
  assertEquals(2, ss.size());
  assertEquals("seventy", ss.getCurrent());
  ss.start();
  assertEquals("seven", ss.getCurrent());
  ss.advance();
  assertEquals("seventy", ss.getCurrent());
 }
 public void test73() {
  ss.add("seven");
  ss.add("seventy");
  ss.add("Seventy");
  ss.add("Seven");
  ss.start();
  ss.advance();
  ss.advance();
  assertEquals("seventy", ss.getCurrent());
  ss.removeCurrent();
  assertEquals("Seventy", ss.getCurrent());
 }
 public void test74() {
  ss.add("seven");
  ss.add("seventy");
  ss.add("Seventy-seven");
  ss.add("Seven");
  ss.add("sevens");
  ss.add("SEVEN");
  ss.add("Seventy");
  ss.start();
  ss.advance();
  ss.advance();
  ss.advance();
  ss.advance();
  assertEquals("seventy", ss.getCurrent());
  ss.removeCurrent();
  assertEquals("Seventy", ss.getCurrent());
 }
 public void test75() {
  ss.add("seven");
  ss.add("five");
  ss.add("Five");
  ss.add("FIVE");
  ss.add("eight");
  ss.add("seventy");
  ss.add("SEVEN");
  ss.add("seventy-five");
  ss.start();
  ss.advance();
  ss.advance();
  ss.advance();
  ss.advance();
  assertEquals("seven", ss.getCurrent());
  ss.removeCurrent();
  assertEquals("SEVEN", ss.getCurrent());
  ss.advance();
  assertEquals("seventy", ss.getCurrent());
  ss.advance();
  assertEquals("seventy-five", ss.getCurrent());
 }
 public void test77() {
  ss.add("seven");
  ss.add("Seven");
  ss.add("seventy");
  ss.add("seven");
  ss.removeCurrent();
  assertEquals("seventy", ss.getCurrent());
  ss.start();
  assertEquals("seven", ss.getCurrent());
  ss.advance();
  assertEquals("Seven", ss.getCurrent());
  ss.advance();
  assertEquals("seventy", ss.getCurrent());
 }
 /// test9N: testing clone
 public void test90() {
  SortedSequencec = s.clone();
  assertFalse(c.isCurrent());
  assertEquals(0, c.size());
 }
 public void test91() {
  s.add(b1);
  SortedSequencec = s.clone();
  assertTrue(s.isCurrent());
  assertSame(b1,s.getCurrent()); s.advance();
  assertFalse(s.isCurrent());
  assertTrue(c.isCurrent());
  assertSame(b1,c.getCurrent()); c.advance();
  assertFalse(c.isCurrent());
 }
 public void test92() {
  s.add(b1);
  s.advance();
  SortedSequencec = s.clone();
  assertFalse(s.isCurrent());
  assertFalse(c.isCurrent());
  c.start();
  assertTrue(c.isCurrent());
  assertSame(b1,c.getCurrent());
 }
 public void test93() {
  s.add(b1);
  s.add(b2);
  SortedSequencec = s.clone();
  assertTrue(s.isCurrent());
  assertTrue(c.isCurrent());
  assertSame(b2,s.getCurrent());
  assertSame(b2,c.getCurrent());
  s.advance();
  c.advance();
  assertFalse(s.isCurrent());
  assertFalse(c.isCurrent());
 }
 public void test94() {
  s.add(b2);
  s.add(b1);
  s.add(b3);
  s.start();
  SortedSequencec = s.clone();
  assertSame(b1,s.getCurrent());
  assertSame(b1,c.getCurrent());
  s.advance();
  c.advance();
  assertTrue(s.isCurrent());
  assertTrue(c.isCurrent());
  assertSame(b2,s.getCurrent());
  assertSame(b2,c.getCurrent());
  s.advance();
  c.advance();
  assertTrue(s.isCurrent());
  assertTrue(c.isCurrent());
  assertSame(b3,s.getCurrent());
  assertSame(b3,c.getCurrent());
 }
 public void test95() {
  s.add(b1);
  SortedSequencec = s.clone();
  s.add(b2);
  assertSame(b2,s.getCurrent());
  assertSame(b1,c.getCurrent());
  s.advance();
  assertFalse(s.isCurrent());
  c.advance();
  assertFalse(c.isCurrent());
  assertEquals(1,c.size());
  assertEquals(2,s.size());
 }
 public void test96() {
  s.add(b1);
  s.add(b2);
  SortedSequencec = s.clone();
  s.add(b3);
  assertSame(b3,s.getCurrent());
  assertSame(b2,c.getCurrent());
  c.advance();
  s.advance();
  assertFalse(s.isCurrent());
  assertFalse(c.isCurrent());
  assertEquals(2,c.size());
  assertEquals(3,s.size());
 }
 public void test97() {
  s.add(b1);
  s.add(b2);
  s.add(b3);
  s.start();
  SortedSequencec = s.clone();
  assertSame(b1,s.getCurrent());
  assertSame(b1,c.getCurrent());
  s.removeCurrent();
  assertSame(b2,s.getCurrent());
  assertSame(b1,c.getCurrent());
  assertEquals(2,s.size());
  assertEquals(3,c.size());
 }
 public void test98() {
  s.add(64);
  s.add(32);
  s.add(96);
  s.add(16);
  s.add(48);
  s.add(80);
  s.add(8);
  s.add(24);
  s.add(40);
  s.add(56);
  s.add(72);
  s.add(88);
  for (int i=4; i < 98; i += 8) {
   s.add(i);
  }
  for (int i=2; i < 98; i += 4) {
   s.add(i);
  }
  for (int i=1; i < 98; i += 2) {
   s.add(i);
  }
  SortedSequencec = s.clone();
  assertEquals(97, c.getCurrent().intValue());
  c.start();
  assertEquals(97, c.getCurrent().intValue());
  c.removeCurrent();
  s.start();
  assertEquals(Integer.valueOf(97), s.getCurrent());
  s.advance();
  for (int i=1; i < 97; ++i) {
   assertEquals(97-i,s.getCurrent().intValue());
   assertEquals(97-i,c.getCurrent().intValue());
   s.advance();
   c.advance();
  }
 }
 public void test99() {
  s.add(b1);
  s.add(b2);
  s.add(b3);
  s.start();
  s.advance();
  SortedSequencec = s.clone();
  c.removeCurrent();
  s.add(b4);
  assertEquals(4, s.size());
  assertEquals(2, c.size());
  s.start();
  c.start();
  assertSame(b1, s.getCurrent());
  assertSame(b1, c.getCurrent());
  s.advance();
  c.advance();
  assertSame(b2, s.getCurrent());
  assertSame(b3, c.getCurrent());
  s.advance();
  c.advance();
  assertSame(b3, s.getCurrent());
  assertFalse(c.isCurrent());
 }
}

Related Samples

Explore our Java Assignments samples showcasing fundamental concepts like loops, arrays, object-oriented programming, and more. Discover solutions crafted to aid understanding and inspire learning in Java programming. Perfect for students seeking clarity and guidance in their assignments.

See All Samples

Step-by-Step Guide: Building a JavaScript Report Generator

Java

Word Count

3961 Words

Writer Name:Chloe Wong

Total Orders:590

Satisfaction rate:

Java Breakout Game Development Guide

Java

Word Count

5749 Words