コード例 #1
0
static int test_jorm_array_manipulations(void)
{
	struct bob **a1 = NULL, **a2 = NULL;
	struct bob *b, *b2, *b3;

	b = JORM_ARRAY_APPEND_bob(&a1);
	EXPECT_NOT_EQUAL(b, NULL);
	EXPECT_EQUAL(b->a, JORM_INVAL_INT);
	EXPECT_NOT_EQUAL(a1[0], NULL);
	JORM_ARRAY_REMOVE_bob(&a1, b);
	EXPECT_EQUAL(a1[0], NULL);
	b = JORM_ARRAY_APPEND_bob(&a2);
	b->a = 1;
	b2 = JORM_ARRAY_APPEND_bob(&a2);
	b2->a = 2;
	b3 = JORM_ARRAY_APPEND_bob(&a2);
	b3->a = 3;
	JORM_ARRAY_REMOVE_bob(&a2, b2);
	EXPECT_EQUAL(a2[0], b);
	EXPECT_EQUAL(a2[1], b3);
	EXPECT_EQUAL(a2[2], NULL);
	JORM_ARRAY_FREE_bob(&a1);
	JORM_ARRAY_FREE_bob(&a2);
	return 0;
}
コード例 #2
0
int main(int argc, char** argv)
{
  struct sockaddr_in server_addr, client_addr;
  socklen_t client_len;
  int fd, conn_fd, r;
  char buf[4 * NBYTES], *pbuf = buf;
  struct iovec iov;
  struct msghdr msg = { NULL, 0, &iov, 1, NULL,	0, 0 };
  
  
  server_addr.sin_family = AF_INET;
  server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
  server_addr.sin_port = htons(1080);

  PRINT("Trying socket()... ");
  fd = socket(PF_INET, SOCK_DGRAM, 0);
  EXPECT_SUCCESS(fd);

  PRINT("Trying bind()... ");
  r = bind(fd, (const struct sockaddr *) &server_addr, sizeof(server_addr));
  EXPECT_SUCCESS(r);

  PRINT("Trying recvfrom()... ");
  client_len = sizeof(client_addr);
  r = recvfrom(fd, pbuf, NBYTES, 0, (struct sockaddr *) &client_addr, &client_len);
  EXPECT_EQUAL(r, NBYTES);
  ASSUME_EQUAL_STR(pbuf, "foo");
  pbuf += NBYTES;
  
  PRINT("Trying recvmsg()... ");
  iov.iov_base = pbuf;
  iov.iov_len = NBYTES;
  r = recvmsg(fd, &msg, 0);
  EXPECT_EQUAL(r, NBYTES);
  ASSUME_EQUAL_STR(pbuf, "bar");
  pbuf += NBYTES;

  PRINT("Trying recv()... ");
  r = recv(fd, pbuf, NBYTES, 0);
  EXPECT_EQUAL(r, NBYTES);
  ASSUME_EQUAL_STR(pbuf, "baz");
  pbuf += NBYTES;

  PRINT("Trying read()... ");
  r = read(fd, pbuf, NBYTES);
  EXPECT_EQUAL(r, NBYTES);
  ASSUME_EQUAL_STR(pbuf, "qux");
  pbuf += NBYTES;

  PRINT("Trying sendto()... ");
  r = sendto(fd, buf, pbuf - buf, 0, (const struct sockaddr *) &client_addr, client_len);
  EXPECT_EQUAL(r, pbuf - buf);
  
  PRINT("Trying close()... ");
  r = close(fd);
  EXPECT_SUCCESS(r);

  printf("Success\n");
  return EXIT_SUCCESS;
}
コード例 #3
0
int main(int argc, char **argv)
{
    struct s2n_connection *conn;
    uint8_t mac_key[] = "sample mac key";
    uint8_t aes128_key[] = "123456789012345";
    struct s2n_blob aes128 = {.data = aes128_key,.size = sizeof(aes128_key) };
    uint8_t random_data[S2N_LARGE_RECORD_LENGTH + 1];
    struct s2n_blob r = {.data = random_data, .size = sizeof(random_data)};

    BEGIN_TEST();

    EXPECT_NOT_NULL(conn = s2n_connection_new(S2N_SERVER));
    EXPECT_SUCCESS(s2n_get_urandom_data(&r));

    /* Peer and we are in sync */
    conn->server = &conn->secure;
    conn->client = &conn->secure;

    /* test the AES128 cipher with a SHA1 hash */
    conn->secure.cipher_suite->cipher = &s2n_aes128;
    conn->secure.cipher_suite->hmac_alg = S2N_HMAC_SHA1;
    EXPECT_SUCCESS(conn->secure.cipher_suite->cipher->get_encryption_key(&conn->secure.server_key, &aes128));
    EXPECT_SUCCESS(conn->secure.cipher_suite->cipher->get_decryption_key(&conn->secure.client_key, &aes128));
    EXPECT_SUCCESS(s2n_hmac_init(&conn->secure.client_record_mac, S2N_HMAC_SHA1, mac_key, sizeof(mac_key)));
    EXPECT_SUCCESS(s2n_hmac_init(&conn->secure.server_record_mac, S2N_HMAC_SHA1, mac_key, sizeof(mac_key)));
    conn->actual_protocol_version = S2N_TLS11;

    /* Align the record size, then subtract 20 bytes for the HMAC, 16 bytes for the explicit IV, and one byte
     * for the padding length byte.
     */
    int small_aligned_payload = S2N_SMALL_FRAGMENT_LENGTH - (S2N_SMALL_FRAGMENT_LENGTH % 16) - 20 - 16 - 1;
    int large_aligned_payload = S2N_LARGE_FRAGMENT_LENGTH - (S2N_LARGE_FRAGMENT_LENGTH % 16) - 20 - 16 - 1;

    int bytes_written;

    /* Check the default: small record */
    EXPECT_SUCCESS(s2n_stuffer_wipe(&conn->out));
    EXPECT_SUCCESS(bytes_written = s2n_record_write(conn, TLS_APPLICATION_DATA, &r));
    EXPECT_EQUAL(bytes_written, small_aligned_payload);

    /* Check explicitly small records */
    EXPECT_SUCCESS(s2n_connection_prefer_low_latency(conn));
    EXPECT_SUCCESS(s2n_stuffer_wipe(&conn->out));
    EXPECT_SUCCESS(bytes_written = s2n_record_write(conn, TLS_APPLICATION_DATA, &r));
    EXPECT_EQUAL(bytes_written, small_aligned_payload);

    /* Check explicitly large records */
    EXPECT_SUCCESS(s2n_connection_prefer_throughput(conn));
    EXPECT_SUCCESS(s2n_stuffer_wipe(&conn->out));
    EXPECT_SUCCESS(bytes_written = s2n_record_write(conn, TLS_APPLICATION_DATA, &r));
    EXPECT_EQUAL(bytes_written, large_aligned_payload);

    /* Clean up */
    EXPECT_SUCCESS(conn->secure.cipher_suite->cipher->destroy_key(&conn->secure.server_key));
    EXPECT_SUCCESS(conn->secure.cipher_suite->cipher->destroy_key(&conn->secure.client_key));
    EXPECT_SUCCESS(s2n_connection_free(conn));
    EXPECT_SUCCESS(s2n_hmac_init(&conn->secure.server_record_mac, S2N_HMAC_SHA1, mac_key, sizeof(mac_key)));
    
    END_TEST();
}
コード例 #4
0
ファイル: StringTests.cpp プロジェクト: relrod/magpie
  void StringTests::subscript()
  {
    gc<String> s = String::create("abcd");

    EXPECT_EQUAL('a', (*s)[0]);
    EXPECT_EQUAL('b', (*s)[1]);
    EXPECT_EQUAL('c', (*s)[2]);
    EXPECT_EQUAL('d', (*s)[3]);
  }
コード例 #5
0
void
Test::requireThatGenerationCanBeIncreased()
{
    GenerationHandler gh;
    EXPECT_EQUAL(0u, gh.getCurrentGeneration());
    EXPECT_EQUAL(0u, gh.getFirstUsedGeneration());
    gh.incGeneration();
    EXPECT_EQUAL(1u, gh.getCurrentGeneration());
    EXPECT_EQUAL(1u, gh.getFirstUsedGeneration());
}
コード例 #6
0
ファイル: LexerTests.cpp プロジェクト: relrod/magpie
  void LexerTests::stringLiteral()
  {
    gc<String> code = String::create("\"st\\nr\"");
    gc<SourceFile> source = new SourceFile(String::create("<file>"), code);
    Lexer lexer(source);

    gc<Token> token = lexer.readToken();
    EXPECT_EQUAL(TOKEN_STRING, token->type());
    EXPECT_EQUAL("st\nr", *token->text());
  }
コード例 #7
0
ファイル: StringTests.cpp プロジェクト: relrod/magpie
  void StringTests::create()
  {
    gc<String> s1 = String::create("some text");
    gc<String> s2 = String::create("more");

    EXPECT_EQUAL(9, s1->length());
    EXPECT_EQUAL("some text", *s1);

    EXPECT_EQUAL(4, s2->length());
    EXPECT_EQUAL("more", *s2);
  }
コード例 #8
0
void Test::testOptionsAfterArguments()
{
    AppOptions opts("myapp bar --foo baz");
    std::string option;
    std::string argument;
    ProgramOptions options(opts.getArgCount(), opts.getArguments());
    options.addOption("foo", option, "Description");
    options.addArgument("arg", argument, "Description");
    options.parse();
    EXPECT_EQUAL("baz", option);
    EXPECT_EQUAL("bar", argument);
}
コード例 #9
0
static int test_jorm_init(void)
{
	struct bob *b1 = JORM_INIT_bob();
	EXPECT_NOT_EQUAL(b1, NULL);
	EXPECT_EQUAL(b1->a, JORM_INVAL_INT);
	EXPECT_EQUAL(b1->b, JORM_INVAL_DOUBLE);
	EXPECT_EQUAL(b1->c, JORM_INVAL_STR);
	EXPECT_EQUAL(b1->d, JORM_INVAL_NESTED);
	EXPECT_EQUAL(b1->e, JORM_INVAL_BOOL);
	JORM_FREE_bob(b1);
	return 0;
}
コード例 #10
0
ファイル: ArrayTests.cpp プロジェクト: relrod/magpie
 void ArrayTests::lastIndexOf()
 {
   Array<char> array;
   array.add('a');
   array.add('b');
   array.add('c');
   array.add('b');
   array.add('e');
   
   EXPECT_EQUAL(3, array.lastIndexOf('b'));
   EXPECT_EQUAL(2, array.lastIndexOf('c'));
   EXPECT_EQUAL(-1, array.lastIndexOf('z'));
 }
コード例 #11
0
ファイル: printabletest.cpp プロジェクト: songhtdo/vespa
void
Test::testAsciiVariant()
{
    AsciiFoo foo(19);

    EXPECT_EQUAL("19", foo.toString());
    EXPECT_EQUAL("AsciiFoo(19)",
                 foo.toString(vespalib::AsciiPrintable::VERBOSE));
    {
        vespalib::asciistream as;
        as << foo;
        EXPECT_EQUAL("19", as.str());

        std::ostringstream ost;
        ost << foo;
        EXPECT_EQUAL("19", ost.str());
    }

    AsciiBar bar(3);
    EXPECT_EQUAL("3", bar.toString());
    EXPECT_EQUAL("AsciiBar() {\n"
                 "  AsciiFoo(3)\n"
                 "}", bar.toString(vespalib::AsciiPrintable::VERBOSE));
    {
        vespalib::asciistream as;
        as << bar;
        EXPECT_EQUAL("3", as.str());

        std::ostringstream ost;
        ost << bar;
        EXPECT_EQUAL("3", ost.str());
    }
}
コード例 #12
0
ファイル: ArrayTests.cpp プロジェクト: relrod/magpie
  void ArrayTests::truncate()
  {
    Array<char> array;
    array.add('a');
    array.add('b');
    array.add('c');
    array.add('d');
    array.add('e');
    
    EXPECT_EQUAL(5, array.count());
    
    // Truncate to greater size does nothing.
    array.truncate(7);
    EXPECT_EQUAL(5, array.count());
    
    // Truncate to same size does nothing.
    array.truncate(5);
    EXPECT_EQUAL(5, array.count());
    
    array.truncate(3);
    EXPECT_EQUAL(3, array.count());
    EXPECT_EQUAL('a', array[0]);
    EXPECT_EQUAL('b', array[1]);
    EXPECT_EQUAL('c', array[2]);

    array.truncate(0);
    EXPECT_EQUAL(0, array.count());
  }
コード例 #13
0
static int test3(void)
{
	size_t i;
	int ret;
	char err[512] = { 0 };
	const char in_str[] = "{ \"a\": 1, \"b\": 2.500000, "
		"\"c\": \"hi there\", \"d\": { \"a\": 0 }, "
		"\"e\": false, \"f\": [ { \"a\": 1 }, "
		"{ \"a\": 2 } ], \"x\" : 5, \"y\" : 1.5 }";
	int expected_array_val[] = { 1, 2, 6 };
	struct json_object* jo = NULL;
	struct bob *my_bob = NULL;
	struct abbie* final_abbie;

	jo = parse_json_string(in_str, err, sizeof(err));
	if (err[0]) {
		fprintf(stderr, "parse_json_string error: %s\n", err);
		ret = EXIT_FAILURE;
		goto done;
	}
	my_bob = JORM_FROMJSON_bob(jo);
	if (!my_bob) {
		fprintf(stderr, "JORM_FROMJSON: OOM\n");
		ret = EXIT_FAILURE;
		goto done;
	}
	ret = 0;
	EXPECT_NONZERO(my_bob->a == 1);
	EXPECT_NONZERO(my_bob->b == 2.5);
	EXPECT_ZERO(my_bob->extra_data);
	final_abbie = JORM_ARRAY_APPEND_abbie(&my_bob->f);
	EXPECT_NOT_EQUAL(final_abbie, NULL);
	final_abbie->a = 6;
	for (i = 0; i < sizeof(expected_array_val) /
			sizeof(expected_array_val[0]); ++i) {
		EXPECT_EQUAL(my_bob->f[i]->a, expected_array_val[i]);
	}
	EXPECT_EQUAL(my_bob->g->x, 5);
	EXPECT_EQUAL(my_bob->g->y, 1.5);
done:
	if (jo) {
		json_object_put(jo);
		jo = NULL;
	}
	if (my_bob) {
		JORM_FREE_bob(my_bob);
		my_bob = NULL;
	}
	return ret;
}
コード例 #14
0
void Test::testAllHiddenOption()
{
    AppOptions opts("myapp --foo bar");
    std::string option;
    ProgramOptions options(opts.getArgCount(), opts.getArguments());
    options.addOption("", option, "Description");
    options.addHiddenIdentifiers("foo");
    std::ostringstream actual;
    options.writeSyntaxPage(actual);
    std::string expected("\nUsage: myapp\n");
    EXPECT_EQUAL(expected, actual.str());

    options.parse();
    EXPECT_EQUAL("bar", option);
}
コード例 #15
0
int main(int argc, char **argv)
{
    struct s2n_stuffer dhparams_in, dhparams_out;
    struct s2n_dh_params dh_params;
    struct s2n_blob b;

    BEGIN_TEST();

    EXPECT_EQUAL(s2n_get_private_random_bytes_used(), 0);

    /* Parse the DH params */
    b.data = dhparams;
    b.size = sizeof(dhparams);
    EXPECT_SUCCESS(s2n_stuffer_alloc(&dhparams_in, sizeof(dhparams)));
    EXPECT_SUCCESS(s2n_stuffer_alloc(&dhparams_out, sizeof(dhparams)));
    EXPECT_SUCCESS(s2n_stuffer_write(&dhparams_in, &b));
    EXPECT_SUCCESS(s2n_stuffer_dhparams_from_pem(&dhparams_in, &dhparams_out));
    b.size = s2n_stuffer_data_available(&dhparams_out);
    b.data = s2n_stuffer_raw_read(&dhparams_out, b.size);
    EXPECT_SUCCESS(s2n_pkcs3_to_dh_params(&dh_params, &b));

    EXPECT_SUCCESS(s2n_dh_generate_ephemeral_key(&dh_params));
    
    /* Verify that our DRBG is called and that over-riding works */
    EXPECT_NOT_EQUAL(s2n_get_private_random_bytes_used(), 0);

    EXPECT_SUCCESS(s2n_dh_params_free(&dh_params));
    EXPECT_SUCCESS(s2n_stuffer_free(&dhparams_out));
    EXPECT_SUCCESS(s2n_stuffer_free(&dhparams_in));

    END_TEST();
}
コード例 #16
0
void Test::testSyntaxPage() {
    AppOptions opts("myapp");
    MyOptions options(opts.getArgCount(), opts.getArguments());
    std::ostringstream actual;
    options.writeSyntaxPage(actual);

    std::string expected(
"\nA test program to see if this utility works.\n\n"
"Usage: myapp [options] <argString> <argInt> [argOptionalString] [argSecondOptional]\n\n"
"Arguments:\n"
" argString (string)      : Required string argument.\n"
" argInt (int)            : Required int argument.\n"
" argOptionalString (string)\n"
"                         : Optional string argument with a long description so\n"
"                           we can see that it will be broken correctly.\n"
"                           (optional)\n"
" argSecondOptional (int) : Yet another optional argument (optional)\n\n"
"Options:\n"
" --uintopt -u <uint>  : Sets an unsigned int (required)\n"
" -b --bool            : Enables a flag\n"
" --boolwithdef        : If set turns to false\n"
" --intopt -i <int>    : Sets a signed int (default 5)\n"
" --floatopt <float>   : Sets a float\n"
"                        Multiline baby (default 4)\n"
" --string -s <string> : Sets a string value. This is a very long description\n"
"                        that should be broken down into multiple lines in some\n"
"                        sensible way. (default \"ballalaika\")\n\n"
"Advanced options:\n"
" -p --properties <key> <value> : Property map (default empty)\n"
    );
    EXPECT_EQUAL(expected, actual.str());
}
コード例 #17
0
void
Test::requireThatGenerationCanGrowLarge()
{
    GenerationHandler gh;
    std::deque<GenGuard> guards;
    for (size_t i = 0; i < 10000; ++i) {
        EXPECT_EQUAL(i, gh.getCurrentGeneration());
        guards.push_back(gh.takeGuard()); // take guard on current generation
        if (i >= 128) {
            EXPECT_EQUAL(i - 128, gh.getFirstUsedGeneration());
            guards.pop_front();
            EXPECT_EQUAL(128u, gh.getGenerationRefCount());
        }
        gh.incGeneration();
    }
}
コード例 #18
0
ファイル: ArrayTests.cpp プロジェクト: relrod/magpie
 void ArrayTests::create()
 {
   {
     Array<int> array;
     
     EXPECT_EQUAL(0, array.count());
     EXPECT_EQUAL(0, array.capacity());
   }
   
   {
     Array<int> array(5);
     
     EXPECT_EQUAL(0, array.count());
     EXPECT(array.capacity() >= 5);
   }
 }
コード例 #19
0
  // TODO: hacky, parses arbitrary code string into a module
  void ParserTests::testCode(const char* sourceString, const char* expected)
  {
    gc<String> code = String::create(sourceString);
    ErrorReporter reporter;
    gc<SourceFile> source = new SourceFile(String::create("<file>"), code);
    Parser parser(source, reporter);
    gc<ModuleAst> module = parser.parseModule();

    int numErrors = reporter.numErrors();

    EXPECT_EQUAL(0, numErrors);

    if (numErrors == 0) {
        gc<String> text = module->body()->toString();
        EXPECT_EQUAL(expected, *text);
    }
  }
コード例 #20
0
ファイル: messages60test.cpp プロジェクト: songhtdo/vespa
bool Messages60Test::testStatBucketMessage() {
    StatBucketMessage msg(document::BucketId(16, 123), "id.user=123");
    msg.setBucketSpace("andrei");

    EXPECT_EQUAL(MESSAGE_BASE_LENGTH + 27u + serializedLength("andrei"), serialize("StatBucketMessage", msg));

    for (uint32_t lang = 0; lang < NUM_LANGUAGES; ++lang) {
        mbus::Routable::UP obj = deserialize("StatBucketMessage", DocumentProtocol::MESSAGE_STATBUCKET, lang);
        if (EXPECT_TRUE(obj.get() != NULL)) {
            StatBucketMessage &ref = static_cast<StatBucketMessage&>(*obj);
            EXPECT_EQUAL(document::BucketId(16, 123), ref.getBucketId());
            EXPECT_EQUAL("id.user=123", ref.getDocumentSelection());
            EXPECT_EQUAL("andrei", ref.getBucketSpace());
        }
    }
    return true;
}
コード例 #21
0
ファイル: StringTests.cpp プロジェクト: relrod/magpie
 void StringTests::concat()
 {
   gc<String> s1 = String::create("first");
   gc<String> s2 = String::create("second");
   gc<String> result = String::concat(s1, s2);
   
   EXPECT_EQUAL("firstsecond", *result);
 }
コード例 #22
0
ファイル: messages60test.cpp プロジェクト: songhtdo/vespa
bool Messages60Test::testGetBucketListMessage() {
    GetBucketListMessage msg(document::BucketId(16, 123));
    msg.setLoadType(_loadTypes["foo"]);
    msg.setBucketSpace("beartato");
    EXPECT_EQUAL(string("foo"), msg.getLoadType().getName());
    EXPECT_EQUAL(MESSAGE_BASE_LENGTH + 12u + serializedLength("beartato"), serialize("GetBucketListMessage", msg));

    for (uint32_t lang = 0; lang < NUM_LANGUAGES; ++lang) {
        mbus::Routable::UP obj = deserialize("GetBucketListMessage", DocumentProtocol::MESSAGE_GETBUCKETLIST, lang);
        if (EXPECT_TRUE(obj.get() != NULL)) {
            GetBucketListMessage &ref = static_cast<GetBucketListMessage&>(*obj);
            EXPECT_EQUAL(string("foo"), ref.getLoadType().getName());
            EXPECT_EQUAL(document::BucketId(16, 123), ref.getBucketId());
            EXPECT_EQUAL("beartato", ref.getBucketSpace());
        }
    }
    return true;
}
コード例 #23
0
ファイル: s2n_ecc_test.c プロジェクト: alexw91/s2n
int main(int argc, char **argv)
{
    BEGIN_TEST();

    /* Test generate->write->read->compute_shared with all supported curves */
    for (int i = 0; i < sizeof(s2n_ecc_supported_curves) / sizeof(s2n_ecc_supported_curves[0]); i++) {
        struct s2n_ecc_params server_params, client_params;
        struct s2n_stuffer wire;
        struct s2n_blob server_shared, client_shared, ecdh_params_sent, ecdh_params_received;

        EXPECT_SUCCESS(s2n_stuffer_growable_alloc(&wire, 1024));

        /* Server generates a key for a given curve */
        server_params.negotiated_curve = &s2n_ecc_supported_curves[i];
        EXPECT_SUCCESS(s2n_ecc_generate_ephemeral_key(&server_params));
        /* Server sends the public */
        EXPECT_SUCCESS(s2n_ecc_write_ecc_params(&server_params, &wire, &ecdh_params_sent));
        /* Client reads the public */
        struct s2n_ecdhe_raw_server_params ecdhe_data = {{0}};
        EXPECT_SUCCESS(s2n_ecc_read_ecc_params(&wire, &ecdh_params_received, &ecdhe_data));
        EXPECT_SUCCESS(s2n_ecc_parse_ecc_params(&client_params, &ecdhe_data));

        /* The client got the curve */
        EXPECT_EQUAL(client_params.negotiated_curve, server_params.negotiated_curve);

        /* Client sends its public */
        EXPECT_SUCCESS(s2n_ecc_compute_shared_secret_as_client(&client_params, &wire, &client_shared));
        /* Server receives it */
        EXPECT_SUCCESS(s2n_ecc_compute_shared_secret_as_server(&server_params, &wire, &server_shared));
        /* Shared is the same for the client and the server */
        EXPECT_EQUAL(client_shared.size, server_shared.size);
        EXPECT_BYTEARRAY_EQUAL(client_shared.data, server_shared.data, client_shared.size);

        /* Clean up */
        EXPECT_SUCCESS(s2n_stuffer_free(&wire));
        EXPECT_SUCCESS(s2n_free(&server_shared));
        EXPECT_SUCCESS(s2n_free(&client_shared));
        EXPECT_SUCCESS(s2n_ecc_params_free(&server_params));
        EXPECT_SUCCESS(s2n_ecc_params_free(&client_params));
    }

    END_TEST();
}
コード例 #24
0
int test_str_to_int(void)
{
	int i;
	char err[512] = { 0 };

	err[0] = '\0';
	str_to_int("123", 10, &i, err, sizeof(err));
	EXPECT_ZERO(err[0]);
	EXPECT_EQUAL(i, 123);

	err[0] = '\0';
	str_to_int("0", 10, &i, err, sizeof(err));
	EXPECT_ZERO(err[0]);
	EXPECT_EQUAL(i, 0);

	err[0] = '\0';
	str_to_int("", 10, &i, err, sizeof(err));
	EXPECT_NONZERO(err[0]);

	err[0] = '\0';
	str_to_int("10b", 10, &i, err, sizeof(err));
	EXPECT_NONZERO(err[0]);

	err[0] = '\0';
	str_to_int("f", 16, &i, err, sizeof(err));
	EXPECT_ZERO(err[0]);
	EXPECT_EQUAL(i, 15);

	err[0] = '\0';
	str_to_int("8589934592", 10, &i, err, sizeof(err));
	EXPECT_NONZERO(err[0]);

	err[0] = '\0';
	str_to_int("2147483647", 10, &i, err, sizeof(err));
	EXPECT_ZERO(err[0]);
	EXPECT_EQUAL(i, 2147483647);

	err[0] = '\0';
	str_to_int("blah", 10, &i, err, sizeof(err));
	EXPECT_NONZERO(err[0]);

	return 0;
}
コード例 #25
0
ファイル: StringTests.cpp プロジェクト: relrod/magpie
  void StringTests::substring()
  {
    gc<String> s = String::create("abcdef");

    // Zero-length.
    gc<String> sub = s->substring(3, 3);
    EXPECT_EQUAL("", *sub);

    // From beginning.
    sub = s->substring(0, 2);
    EXPECT_EQUAL("ab", *sub);

    // In middle.
    sub = s->substring(2, 5);
    EXPECT_EQUAL("cde", *sub);

    // To end.
    sub = s->substring(4, 6);
    EXPECT_EQUAL("ef", *sub);
  }
コード例 #26
0
void Test::testVectorArgument()
{
    AppOptions opts("myapp foo bar baz");
    std::vector<std::string> args;
    ProgramOptions options(opts.getArgCount(), opts.getArguments());
    options.addListArgument("ids", args, "Vector element");
    std::ostringstream actual;
    options.writeSyntaxPage(actual);
    std::string expected(
"\nUsage: myapp [ids...]\n\n"
"Arguments:\n"
" ids (string[]) : Vector element\n"
    );
    EXPECT_EQUAL(expected, actual.str());

    options.parse();
    EXPECT_EQUAL(3u, args.size());
    EXPECT_EQUAL("foo", args[0]);
    EXPECT_EQUAL("bar", args[1]);
    EXPECT_EQUAL("baz", args[2]);
}
コード例 #27
0
ファイル: MemoryTests.cpp プロジェクト: cburrows/magpie
  void MemoryTests::collect()
  {
    Memory::shutDown();
    
    ConsRoots roots;
    Memory::initialize(&roots, sizeof(Cons) * 400);

    EXPECT_EQUAL(0, Memory::numCollections());

    gc<Cons> notRoot;
    
    // Make two long cons chains, only one of which is rooted.
    gc<Cons>* a = &roots.root;
    gc<Cons>* b = &notRoot;
    int id = 0;
    for (int i = 0; i <= 600; i++)
    {
      a->set(new Cons(id));
      a = &((*a)->next);
      
      b->set(new Cons(id));
      b = &((*b)->next);
      id++;
    }
    
    // Make sure the rooted ones are still valid.
    int last = -1;
    gc<Cons> c = roots.root;
    while (!c.isNull()) {
      EXPECT_EQUAL(last + 1, c->id);
      last = c->id;
      c = c->next;
    }

    // Make sure it actually did a collection.
    EXPECT(Memory::numCollections() > 0);
  }
コード例 #28
0
static int test_copy_fd_to_fd(const char *tempdir, int *next_id,
				const char *buf)
{
	size_t buf_len = strlen(buf);
	ssize_t res;
	char *nbuf, src_file[PATH_MAX], dst_file[PATH_MAX];
	FILE *ifp, *ofp;
	int ret;
	EXPECT_ZERO(zsnprintf(src_file, sizeof(src_file),
		      "%s/src_file.%d", tempdir, *next_id));
	EXPECT_ZERO(zsnprintf(dst_file, sizeof(dst_file),
		      "%s/dst_file.%d", tempdir, *next_id));
	*next_id = *next_id + 1;
	ifp = fopen(src_file, "w");
	if (!ifp) {
		ret = errno;
		return ret;
	}
	EXPECT_EQUAL(fwrite(buf, 1, buf_len, ifp), buf_len);
	ifp = freopen(src_file, "r", ifp);
	if (!ifp) {
		ret = errno;
		return ret;
	}
	ofp = fopen(dst_file, "w");
	if (!ofp) {
		ret = errno;
		fclose(ifp);
		return ret;
	}
	ret = copy_fd_to_fd(fileno(ifp), fileno(ofp));
	EXPECT_ZERO(ret);
	fclose(ofp);
	fclose(ifp);

	nbuf = calloc(1, buf_len + 1);
	EXPECT_NOT_EQUAL(nbuf, NULL);
	res = simple_io_read_whole_file_zt(dst_file, nbuf, buf_len + 1);
	if (res < 0) {
		free(nbuf);
		return res;
	}
	if ((res > 0) && (memcmp(buf, nbuf, buf_len - 1))) {
		free(nbuf);
		return -EIO;
	}
	free(nbuf);
	return 0;
}
コード例 #29
0
ファイル: MemoryTests.cpp プロジェクト: cburrows/magpie
  void MemoryTests::inScopeTempsArePreserved()
  {
    Memory::shutDown();
    
    ConsRoots roots;
    Memory::initialize(&roots, 1024 * 1024);

    AllocScope scope;
    temp<Cons> a = Memory::makeTemp(new Cons(123));
    
    // Force a collection.
    Memory::collect();
    
    EXPECT_EQUAL(123, a->id);
  }
コード例 #30
0
ファイル: printabletest.cpp プロジェクト: songhtdo/vespa
void
Test::testSimple()
{
    Foo foo(3, "myval");
    Bar bar(7, 3, "otherval");

    EXPECT_EQUAL("Foo(val = 3, other size 5)", foo.toString());
    EXPECT_EQUAL("Foo(val = 3, other size 5)", foo.toString(false, "  "));
    EXPECT_EQUAL("Foo(val = 3, other:\n"
               "  myval)", foo.toString(true));
    EXPECT_EQUAL("Foo(val = 3, other:\n"
               "    myval)", foo.toString(true, "  "));

    std::ostringstream ost;
    ost << foo;
    EXPECT_EQUAL("Foo(val = 3, other size 5)", ost.str());

    EXPECT_EQUAL("Bar(7)", bar.toString());
    EXPECT_EQUAL("Bar(7)", bar.toString(false, "  "));
    EXPECT_EQUAL("Bar(7) : Foo(val = 3, other:\n"
               "    otherval)", bar.toString(true));
    EXPECT_EQUAL("Bar(7) : Foo(val = 3, other:\n"
               "      otherval)", bar.toString(true, "  "));
}