then:
        archiveTask.archiveFileName.get() == 'testbasename-testappendix-1.0-src'
    }

    def "archiveFileName with empty extension in provider"() {
        when:
        archiveTask.archiveExtension.set(project.provider { null })

        then:
        archiveTask.archiveFileName.get() == 'testbasename-testappendix-1.0-src'
    }

    def "archiveFileName with empty basename"() {
        when:

		t.Errorf("unnecessary grow")
	}
	a = appendOne_ssa(a, 8)
	expect(t, a, []int{1, 2, 3, 4, 5, 6, 7, 8})
	if &a[0] == &store[0] {
		t.Errorf("didn't grow")
	}
}

func TestAppend(t *testing.T) {
	testAppend(t)

 * this case, we use the "shadowed" capability to check.
 * <p>
 * It remains deeply immutable.
 */
public interface ShadowedCapability extends ImmutableCapability {
    String getAppendix();
    ImmutableCapability getShadowedCapability();

            this.shadowed = new DefaultImmutableCapability(shadowed.getGroup(), shadowed.getName(), shadowed.getVersion());
        }
        this.appendix = appendix;
    }

    @Override
    public String getAppendix() {
        return appendix;
    }

    @Override
    public ImmutableCapability getShadowedCapability() {
        return shadowed;
    }

    @Override
    public String getGroup() {

		panic(fmt.Sprintf("a.Min(%v) = %q, want %q", s2, got, want))
	}

	if got, want := a.SliceMin(s2[:0]), ""; got != want {
		panic(fmt.Sprintf("a.Min(%v) = %q, want %q", s2[:0], got, want))
	}
}

func TestAppend() {
	s := []int{1, 2, 3}
	s = a.Append(s, 4, 5, 6)
	want := []int{1, 2, 3, 4, 5, 6}
	if !a.Equal(s, want) {
		panic(fmt.Sprintf("after a.Append got %v, want %v", s, want))
	}
}

func TestCopy() {

		panic(fmt.Sprintf("_Min(%v) = %q, want %q", s2, got, want))
	}

	if got, want := _SliceMin(s2[:0]), ""; got != want {
		panic(fmt.Sprintf("_Min(%v) = %q, want %q", s2[:0], got, want))
	}
}

func TestAppend() {
	s := []int{1, 2, 3}
	s = _Append(s, 4, 5, 6)
	want := []int{1, 2, 3, 4, 5, 6}
	if !_Equal(s, want) {
		panic(fmt.Sprintf("after _Append got %v, want %v", s, want))
	}
}

func TestCopy() {

	"github.com/google/go-cmp/cmp"
)

// TestAppendixA roundtrips the examples of encoded CBOR data items in RFC 8949 Appendix A. For
// completeness, all examples from the appendix are included, even those those that are rejected by
// this decoder or are re-encoded to a different sequence of CBOR bytes (with explanation).
func TestAppendixA(t *testing.T) {
	hex := func(h string) []byte {
		b, err := hex.DecodeString(h)

  // Add two integers.
  Callable add(TFLIB_CALLABLE_ADAPTOR(AddIntegersTyped));
  auto res = add.Call<Integer>(Integer(3), Integer(1));
  EXPECT_EQ(res->get(), 4);
}

TEST(TypeUneraseCallTest, TestAppend) {
  // Append some indices to a list.
  Callable append(TFLIB_CALLABLE_ADAPTOR(AppendIntegerToList));
  List l;
  TF_ASSERT_OK(append.Call<None>(l, Integer(3)).status());

     */
    @Test
    public void testToHex2() throws Exception {
        assertEquals("0001", StringUtil.toHex(1));
    }

    /**
     * @throws Exception
     */
    @Test
    public void testAppendHex() throws Exception {
        final StringBuilder buf = new StringBuilder();
        StringUtil.appendHex(buf, (byte) 1);
        assertEquals("01", buf.toString());
    }

    /**
     * @throws Exception

                }
            }
            finally {
                f.delete();
            }
        }
    }


    @Test
    public void testAppend () throws IOException {
        try ( SmbFile f = createTestFile() ) {
            try {
                try ( OutputStream os = f.openOutputStream() ) {
                    writeRandom(4096, 3072, os);