public void test_getNewInput() {
        // Test getNewInput method
        ProtwordsItem item = new ProtwordsItem(1, "word");
        assertNull(item.getNewInput());

        item.setNewInput("newword");
        assertEquals("newword", item.getNewInput());
    }

    public void test_setNewInput() {
        // Test setNewInput method
        ProtwordsItem item = new ProtwordsItem(1, "word");

    public void test_createMode() {
        // Test special behavior when id is 0 (create mode)
        StopwordsItem createItem = new StopwordsItem(0, "newword");
        assertTrue(createItem.isUpdated());
        assertEquals("newword", createItem.getNewInput());
        assertEquals("newword", createItem.toLineString());

        // Non-zero id should not auto-set newInput

        ProtwordsItem newItem = new ProtwordsItem(0, "newWord");

        // Insert the item
        protwordsFile.insert(newItem);

        // Verify the item was added
        protwordsFile.reload(null);
        boolean found = false;
        PagingList<ProtwordsItem> list = protwordsFile.selectList(0, 100);
        for (ProtwordsItem item : list) {
            if ("newWord".equals(item.getInput())) {

 * subtype of {@code Network} that provides methods for adding and removing nodes and edges. If you
 * do not need to mutate a network (e.g. if you write a method than runs a read-only algorithm on
 * the network), you should use the non-mutating {@link Network} interface, or an {@link
 * ImmutableNetwork}.
 *
 * <p>You can create an immutable copy of an existing {@code Network} using {@link
 * ImmutableNetwork#copyOf(Network)}:

      "name": {
        "type": "keyword"
      },
      "password": {
        "type": "keyword"
      },
      "surname": {
        "type": "keyword"
      },
      "givenName": {
        "type": "keyword"
      },
      "employeeNumber" : {
        "type" : "keyword"
      },
      "mail" : {
        "type" : "keyword"
      },
      "telephoneNumber" : {
        "type" : "keyword"
      },
      "homePhone" : {

          },
          "groups" : {
            "type" : "keyword"
          },
          "homeDirectory" : {
            "type" : "keyword"
          },
          "homePhone" : {
            "type" : "keyword"
          },
          "homePostalAddress" : {
            "type" : "keyword"
          },
          "initials" : {
            "type" : "keyword"
          },

  public void validateUndirectedEdges() {
    for (Integer node : network.nodes()) {
      new EqualsTester()
          .addEqualityGroup(
              network.inEdges(node), network.outEdges(node), network.incidentEdges(node))
          .testEquals();
      new EqualsTester()
          .addEqualityGroup(
              network.predecessors(node), network.successors(node), network.adjacentNodes(node))
          .testEquals();

    mutableNetwork.addEdge("A", "A", "AA");
    mutableNetwork.addEdge("A", "B", "AB");
    Network<String, String> network = ImmutableNetwork.copyOf(mutableNetwork);

    assertThat(network.edgesConnecting("A", "A")).containsExactly("AA");
    assertThat(network.edgesConnecting("A", "B")).containsExactly("AB");
    assertThat(network.edgesConnecting("B", "A")).isEmpty();
  }

  @Test
  public void edgesConnecting_undirected() {

        "type": "keyword"
      },
      "urls": {
        "type": "keyword"
      },
      "includedUrls": {
        "type": "keyword"
      },
      "excludedUrls": {
        "type": "keyword"
      },
      "includedDocUrls": {
        "type": "keyword"
      },
      "excludedDocUrls": {
        "type": "keyword"
      },
      "configParameter": {
        "type": "keyword"
      },
      "depth": {

{
    "properties": {
      "name": {
        "type": "keyword"
      },
      "paths": {
        "type": "keyword"
      },
      "includedPaths": {
        "type": "keyword"
      },
      "excludedPaths": {
        "type": "keyword"
      },
      "includedDocPaths": {
        "type": "keyword"
      },
      "excludedDocPaths": {
        "type": "keyword"
      },
      "configParameter": {