if (array.length == 1) {
            return StringUtil.capitalize(s);
        }
        final StringBuilder buf = new StringBuilder(40);
        for (final String element : array) {
            buf.append(StringUtil.capitalize(element));
        }
        return buf.toString();
    }

    /**
     * Converts a camel case string to an underscore-separated string.
     * <p>
     * Usage example:

	// Move vector element to scalar.
	XVMOVQ		X0, X31.W[7]    // 1fdcff76
	XVMOVQ		X1, X29.W[0]    // 3dc0ff76
	XVMOVQ		X3, X28.V[3]    // 7cecff76
	XVMOVQ		X4, X27.V[0]    // 9be0ff76
	XVMOVQ		X31.W[7], X0    // e0df0377
	XVMOVQ		X29.W[0], X1    // a1c30377
	XVMOVQ		X28.V[3], X8    // 88ef0377
	XVMOVQ		X27.V[0], X9    // 69e30377

	// Move vector element to vector.
	VMOVQ		V1.B[3], V9.B16 // 298cf772

   * @param data the table data, repeating the sequence row key, column key, value once per mapping
   * @throws IllegalArgumentException if the size of {@code data} isn't a multiple of 3
   * @throws ClassCastException if a data element has the wrong type
   */
  protected abstract Table<String, Integer, C> create(@Nullable Object... data);

  protected void assertSize(int expectedSize) {
    assertEquals(expectedSize, table.size());
  }

  /**
   * Sets {@code table[index]} to {@code entry}, where {@code table} is actually a {@code byte[]},
   * {@code short[]}, or {@code int[]}. The value of {@code entry} should fit in the size of the
   * assigned array element, when seen as an unsigned value. So if {@code table} is a {@code byte[]}
   * then we should have {@code 0 ≤ entry ≤ 255}, and if {@code table} is a {@code short[]} then we

 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
package jcifs;

/**
 * An Access Control Entry (ACE) is an element in a security descriptor
 * such as those associated with files and directories. The Windows OS
 * determines which users have the necessary permissions to access objects
 * based on these entries.
 * <p>

      this.chunks = chunks;
      this.chunkShift = chunkShift;
      this.chunkMask = (1 << chunkShift) - 1;
      int total = 0;
      for (CharSequence element : chunks) {
        total += element.length();
      }
      this.length = total;
    }

    @Override
    public int length() {
      return length;
    }

    @Override
    public char charAt(int index) {

      <name>PersistedToolchains</name>
      <superClass>TrackableBase</superClass>
      <description>
        The {@code &lt;toolchains&gt;} element is the root of the descriptor.
        The following table lists all the possible child elements.
      </description>
      <version>1.0.0+</version>
      <fields>
        <field>
          <name>toolchains</name>
          <version>1.0.0+</version>

    StackTraceElement[] elements = e.getStackTrace();
    for (int i = 0; i < elements.length; i++) {
      StackTraceElement element = elements[i];
      if (element.getClassName().equals(clazz) && element.getMethodName().equals(method)) {
        return i;
      }
    }
    throw new AssertionError(
        "Expected element " + clazz + "." + method + " not found in stack trace", e);
  }

   * insertion order.
   */
  private void populateTShapedGraph() {
    putEdge(2, 1);
    putEdge(1, 4);
    putEdge(1, 3);
    putEdge(1, 2); // Duplicate
    putEdge(4, 5);
  }

  // Element Mutation

  @Test
  public void putEdge_existingNodes() {
    assume().that(graphIsMutable()).isTrue();

    // Adding nodes initially for safety (insulating from possible future

      numCallsToNewTargetIterator++;
      return Lists.newArrayList(1).iterator();
    }

    @Override
    protected void verify(List<Integer> elements) {
      numCallsToVerify++;
      super.verify(elements);
    }
  }

  public void testVerifyGetsCalled() {
    TesterThatCountsCalls tester = new TesterThatCountsCalls();

    tester.test();

    assertEquals(