Helpers.testComparator(comparator, ordered);
  }

  public void testSort() {
    testSort(new long[] {}, new long[] {});
    testSort(new long[] {2}, new long[] {2});
    testSort(new long[] {2, 1, 0}, new long[] {0, 1, 2});
    testSort(new long[] {2, GREATEST, 1, LEAST}, new long[] {LEAST, 1, 2, GREATEST});
  }

  static void testSort(long[] input, long[] expected) {
    input = Arrays.copyOf(input, input.length);

        DuplicateHostHelper helper = new DuplicateHostHelper();
        List<DuplicateHost> testList = new ArrayList<>();

        DuplicateHost testHost = new DuplicateHost();
        testHost.setRegularName("www.test.com");
        testHost.setDuplicateHostName("test.com");
        testList.add(testHost);

        helper.setDuplicateHostList(testList);

        assertEquals(testList, helper.duplicateHostList);

    public void test_constructor_withIdZero() {
        // Test constructor with id = 0 (create mode)
        ProtwordsItem item = new ProtwordsItem(0, "testword");

        assertEquals(0, item.getId());
        assertEquals("testword", item.getInput());
        assertEquals("testword", item.getNewInput());
    }

    public void test_constructor_withNonZeroId() {
        // Test constructor with id != 0 (existing item)

.tags*

# Version file for dockerized build
.dockerized-kube-version-defs

# Web UI
/www/master/node_modules/
/www/master/npm-debug.log
/www/master/shared/config/development.json

# Karma output
/www/test_out

# precommit temporary directories created by ./hack/verify-generated-docs.sh and ./hack/lib/util.sh
/_tmp/
/doc_tmp/

# Test artifacts produced by Prow/kubetest2 jobs
/_artifacts/
/_rundir/

    sink.putByte((byte) 7);
    sink.putBytes(new byte[] {});
    sink.putBytes(new byte[] {8});
    HashCode unused = sink.hash();
    sink.assertInvariants(8);
    sink.assertBytes(expected);
  }

  public void testShort() {
    Sink sink = new Sink(4);
    sink.putShort((short) 0x0201);
    HashCode unused = sink.hash();
    sink.assertInvariants(2);
    sink.assertBytes(new byte[] {1, 2, 0, 0}); // padded with zeros
  }

        // and properly closed even when errors might occur

        protwordsFile.reload(null);

        // Test normal creation and cleanup of ProtwordsUpdater
        ProtwordsItem testItem = new ProtwordsItem(0, "testWord");
        ProtwordsFile.ProtwordsUpdater updater = null;

        try {
            // Create the updater successfully
            updater = protwordsFile.new ProtwordsUpdater(testItem);

    hasher.putBytes(new byte[] {2, 3, 4, 5, 6});
    hasher.putByte((byte) 7);
    hasher.putBytes(new byte[] {});
    hasher.putBytes(new byte[] {8});
    hasher.assertBytes(expected);
  }

  public void testShort() {
    TestHasher hasher = new TestHasher();
    hasher.putShort((short) 0x0201);
    hasher.assertBytes(new byte[] {1, 2});
  }

  public void testInt() {
    TestHasher hasher = new TestHasher();

    sink.putByte((byte) 7);
    sink.putBytes(new byte[] {});
    sink.putBytes(new byte[] {8});
    HashCode unused = sink.hash();
    sink.assertInvariants(8);
    sink.assertBytes(expected);
  }

  public void testShort() {
    Sink sink = new Sink(4);
    sink.putShort((short) 0x0201);
    HashCode unused = sink.hash();
    sink.assertInvariants(2);
    sink.assertBytes(new byte[] {1, 2, 0, 0}); // padded with zeros
  }

        // Set newInputs to non-empty array - not deleted
        item.setNewInputs(new String[] { "something" });
        assertFalse(item.isDeleted());
    }

    public void test_sort() {
        String[] inputs = { "z", "a", "m" };
        String[] newInputs = { "9", "1", "5" };

        CharMappingItem item = new CharMappingItem(1L, inputs, "output");
        item.setNewInputs(newInputs);