*/
          toJoin = Arrays.copyOf(toJoin, expandedCapacity(toJoin.length, toJoin.length + 1));
        }
        toJoin[i++] = toString(part);
      }
      // We might not have seen the expected number of elements, as discussed above.
      if (i != toJoin.length) {
        toJoin = Arrays.copyOf(toJoin, i);
      }
      return String.join(separator, toJoin);
    }
    return join(parts.iterator());

    const auto tensor_interface =
        tensorflow::down_cast<const tensorflow::TensorInterface*>(src->tensor);

    if (dst->dims() != 0) {
      return InvalidArgument(
          "Malformed TF_RESOURCE tensor: expected a scalar, got a tensor with "
          "shape ",
          dst->shape().DebugString());
    }
    *dst = tensorflow::Tensor(tensorflow::DT_RESOURCE, dst->shape());

        try {
            execJob.testAddFessCustomSystemProperties(cmdList, "[invalid(regex");
            fail("Should handle invalid regex");
        } catch (Exception e) {
            // Expected to throw pattern syntax exception
            assertTrue(e instanceof java.util.regex.PatternSyntaxException);
        }
    }

   * Builder} constructor.
   */
  public static <K, V> Builder<K, V> builder() {
    return new Builder<>();
  }

  /**
   * Returns a new builder with a hint for how many distinct keys are expected to be added. The
   * generated builder is equivalent to that returned by {@link #builder}, but may perform better if
   * {@code expectedKeys} is a good estimate.
   *

  // Bulk Operations

  /**
   * Stores a key-value pair in this multimap for each of {@code values}, all using the same key,
   * {@code key}. Equivalent to (but expected to be more efficient than):
   *
   * {@snippet :
   * for (V value : values) {
   *   put(key, value);
   * }
   * }
   *
   * <p>In particular, this is a no-op if {@code values} is empty.
   *

            // When & Then
            SMBProtocolDecodingException exception =
                    assertThrows(SMBProtocolDecodingException.class, () -> response.readBytesWireFormat(buffer, 0));
            assertEquals("Expected structureSize = 60", exception.getMessage());
        }

        @ParameterizedTest
        @ValueSource(ints = { 0, 10, 20, 30 })
        @DisplayName("Should correctly read from different buffer offsets")

 *
 * <p>The tested methods and constructors are invoked -- each time with one parameter being null and
 * the rest not null -- and the test fails if no expected exception is thrown. {@code
 * NullPointerTester} uses best effort to pick non-null default values for many common JDK and Guava
 * types, and also for interfaces and public classes that have public parameter-less constructors.

          // Checking subtype between declared and actual type bounds
          // adds recursive isSubtypeOf() call and feels complicated.
          // There is no contract one way or another as long as isSubtypeOf() works as expected.
          combined.addAll(asList(typeParam.getBounds()));
          if (combined.size() > 1) { // Object is implicit and only useful if it's the only bound.
            combined.remove(Object.class);
          }

     and conditions of the license they choose before applying it.
     Licensors should also secure all rights necessary before
     applying our licenses so that the public can reuse the
     material as expected. Licensors should clearly mark any
     material not subject to the license. This includes other CC-
     licensed material, or material used under an exception or
     limitation to copyright. More considerations for licensors:

expected := &Nat{[]uint{0}} if x.Equal(expected) != 1 { t.Errorf("%+v != %+v", x, expected) } x.Add(y, m) expected = &Nat{[]uint{7}} if x.Equal(expected) != 1 { t.Errorf("%+v != %+v", x, expected) } } func TestExp(t *testing.T) { m := modulusFromBytes([]byte{13}) x := &Nat{[]uint{3}} out := &Nat{[]uint{0}} out.Exp(x, []byte{12}, m) expected := &Nat{[]uint{1}} if out.Equal(expected) != 1 { t.Errorf("%+v != %+v", out, expected) } } func TestExpShort(t *testing.T) { m := modulusFromBytes([]byte{13}) x...