final Matcher matcher = pattern.matcher(line);
            if (matcher.matches()) {
                if (lineNum == 0) {
                    lineNum = Integer.parseInt(matcher.group(1));
                    list.clear();
                }
                list.add(matcher.group(2));
            } else {
                list.add(line);
            }
        }
        if (lineNum == 0 || list.isEmpty()) {

  }

  public void testSkip_structurallyModifiedSkipSomeList() throws Exception {
    List<String> list = newArrayList("a", "b", "c");
    Iterable<String> tail = skip(list, 1);
    list.subList(1, 3).clear();
    list.addAll(0, newArrayList("A", "B", "C"));
    assertThat(tail).containsExactly("B", "C", "a").inOrder();
  }

  public void testSkip_structurallyModifiedSkipAll() throws Exception {

				err = msgp.WrapError(err, "Error")
				return
			}
			zb0001Mask |= 0x4
		default:
			err = dc.Skip()
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	// Clear omitted fields.
	if zb0001Mask != 0x7 {
		if (zb0001Mask & 0x1) == 0 {
			z.Index = nil
		}
		if (zb0001Mask & 0x2) == 0 {
			z.Checksums = nil
		}
		if (zb0001Mask & 0x4) == 0 {
			z.Error = ""

      .openConnection()
      .getInputStream() // Should succeed.
  }

  @Test
  fun clearDispatcherQueue() {
    server.enqueue(MockResponse(body = "A"))
    (server.dispatcher as QueueDispatcher).clear()
    server.enqueue(MockResponse(body = "B"))
    val inputStream =
      server
        .url("/a")
        .toUrl()
        .openConnection()
        .getInputStream()

  }

  public void testSkip_structurallyModifiedSkipSomeList() throws Exception {
    List<String> list = newArrayList("a", "b", "c");
    Iterable<String> tail = skip(list, 1);
    list.subList(1, 3).clear();
    list.addAll(0, newArrayList("A", "B", "C"));
    assertThat(tail).containsExactly("B", "C", "a").inOrder();
  }

  public void testSkip_structurallyModifiedSkipAll() throws Exception {

library, and (2) we offer you this license, which gives you legal
permission to copy, distribute and/or modify the library.

  To protect each distributor, we want to make it very clear that
there is no warranty for the free library.  Also, if the library is
modified by someone else and passed on, the recipients should know
that what they have is not the original version, so that the original

        public boolean match(String url) {
            return true;
        }

        @Override
        public void processUrl(String url) {
        }

        @Override
        public void clear() {
        }
    }

    /**
     * Test implementation of RuleManager for testing
     */
    private static class TestRuleManager implements RuleManager {
        @Override

   *
   * @throws UnsupportedOperationException always
   * @deprecated Unsupported operation.
   */
  @Deprecated
  @Override
  @DoNotCall("Always throws UnsupportedOperationException")
  public final void clear() {
    throw new UnsupportedOperationException();
  }

  /**
   * Guaranteed to throw an exception and leave the table unmodified.
   *
   * @throws UnsupportedOperationException always

        } finally {
            lock.writeLock().unlock();
        }
    }
    
    public void invalidate() {
        lock.writeLock().lock();
        try {
            children.clear();
            isComplete = false;
            hasChanges = true;
        } finally {
            lock.writeLock().unlock();
        }
    }
}
```

### 4.3 Directory Lease Manager
```java

            return rules.contains(rule);
        }

        public List<Rule> getRules() {
            return new ArrayList<>(rules);
        }

        public void clearRules() {
            rules.clear();
        }
    }

    /**
     * Test ResponseProcessor implementation
     */
    public static class TestResponseProcessor implements ResponseProcessor, Serializable {