}

    @Override
    public String toString() {
        return "DocList [contentSize=" + contentSize + ", processingTime=" + processingTime + ", elementData="
                + Arrays.toString(toArray(new Map[size()])) + "]";
    }

     */
    @Override
    void close () throws CIFSException;


    /**
     * @throws CIFSException
     * 
     */
    void release () throws CIFSException;


    /**
     * @return the file size when it was opened
     */
    long getInitialSize ();

        Map artifactMap = project.getArtifactMap();

        assertNotNull( artifactMap, "artifact-map should not be null." );
        assertEquals( 1, artifactMap.size(), "artifact-map should contain 1 element." );

        Artifact artifact = (Artifact) artifactMap.get( key );

        assertNotNull( artifact, "dependency artifact not found in map." );

                try {
                    list.add(Integer.parseInt(value.trim()));
                } catch (final NumberFormatException e) {}
            }
            this.days = new int[list.size()];
            for (int i = 0; i < list.size(); i++) {
                this.days[i] = list.get(i);
            }
            this.delay = delay;
            reverse = compareTime(fromHours, fromMinutes, toHours, toMinutes) < 0;
        }

            cacheEntry = entry;
            return entry.getKey();
          }
        };
      }

      @Override
      public int size() {
        return backingMap.size();
      }

      @Override
      public boolean contains(@CheckForNull Object key) {
        return containsKey(key);
      }
    };
  }

      }
    }
  }

  private static List<Object> subListCopy(Object[] source, int size) {
    final Object[] copy = new Object[size];
    arraycopy(source, 0, copy, 0, size);
    return asList(copy);
  }

  private interface IteratorOperation {
    @Nullable Object execute(Iterator<?> iterator);
  }

  /**

constraints.Null.message        = {item} must be null.
constraints.Past.message        = {item} must be in the past.
constraints.Pattern.message     = {item} must match "{regexp}".
constraints.Size.message        = Size of {item} must be between {min} and {max}.

# ----------------------------------------------------------
#                                        Hibernate Validator

    public void testIncludes() throws Exception {
        final CopyOptions option = new CopyOptions();
        assertThat(option.include(BeanNames.hoge()), is(sameInstance(option)));
        assertThat(option.includePropertyNames.size(), is(1));
        assertThat(option.includePropertyNames.get(0), is("hoge"));
    }

    /**
     * @throws Exception
     */
    @Test
    public void testExcludes() throws Exception {

                20, 'X', "d", 15, 'X', "d", 20, 'X', "d", 1, 'X', "e", 5, 'X');
    SortedMap<Integer, Character> row = sortedTable.row("c");
    assertEquals(2, row.size());
    assertEquals(1, row.tailMap(15).size());
  }

  public void testSubRowClearAndPut() {
    table = create("foo", 1, 'a', "bar", 1, 'b', "foo", 3, 'c');

const (
	magicGNU, versionGNU     = "ustar ", " \x00"
	magicUSTAR, versionUSTAR = "ustar\x00", "00"
	trailerSTAR              = "tar\x00"
)

// Size constants from various tar specifications.
const (
	blockSize  = 512 // Size of each block in a tar stream
	nameSize   = 100 // Max length of the name field in USTAR format
	prefixSize = 155 // Max length of the prefix field in USTAR format