+++ /dev/null
-/*-
- * BSD LICENSE
- *
- * Copyright(c) 2010-2014 Intel Corporation. All rights reserved.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- *
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in
- * the documentation and/or other materials provided with the
- * distribution.
- * * Neither the name of Intel Corporation nor the names of its
- * contributors may be used to endorse or promote products derived
- * from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#include <stdio.h>
-#include <string.h>
-#include <inttypes.h>
-
-#include <rte_string_fns.h>
-
-#include <cmdline_parse.h>
-#include <cmdline_parse_num.h>
-
-#include "test_cmdline.h"
-
-struct num_unsigned_str {
- const char * str;
- uint64_t result;
-};
-
-struct num_signed_str {
- const char * str;
- int64_t result;
-};
-
-const struct num_unsigned_str num_valid_positive_strs[] = {
- /* decimal positive */
- {"0", 0 },
- {"127", INT8_MAX },
- {"128", INT8_MAX + 1 },
- {"255", UINT8_MAX },
- {"256", UINT8_MAX + 1 },
- {"32767", INT16_MAX },
- {"32768", INT16_MAX + 1 },
- {"65535", UINT16_MAX },
- {"65536", UINT16_MAX + 1 },
- {"2147483647", INT32_MAX },
- {"2147483648", INT32_MAX + 1U },
- {"4294967295", UINT32_MAX },
- {"4294967296", UINT32_MAX + 1ULL },
- {"9223372036854775807", INT64_MAX },
- {"9223372036854775808", INT64_MAX + 1ULL},
- {"18446744073709551615", UINT64_MAX },
- /* hexadecimal (no leading zeroes) */
- {"0x0", 0 },
- {"0x7F", INT8_MAX },
- {"0x80", INT8_MAX + 1 },
- {"0xFF", UINT8_MAX },
- {"0x100", UINT8_MAX + 1 },
- {"0x7FFF", INT16_MAX },
- {"0x8000", INT16_MAX + 1 },
- {"0xFFFF", UINT16_MAX },
- {"0x10000", UINT16_MAX + 1 },
- {"0x7FFFFFFF", INT32_MAX },
- {"0x80000000", INT32_MAX + 1U },
- {"0xFFFFFFFF", UINT32_MAX },
- {"0x100000000", UINT32_MAX + 1ULL },
- {"0x7FFFFFFFFFFFFFFF", INT64_MAX },
- {"0x8000000000000000", INT64_MAX + 1ULL},
- {"0xFFFFFFFFFFFFFFFF", UINT64_MAX },
- /* hexadecimal (with leading zeroes) */
- {"0x00", 0 },
- {"0x7F", INT8_MAX },
- {"0x80", INT8_MAX + 1 },
- {"0xFF", UINT8_MAX },
- {"0x0100", UINT8_MAX + 1 },
- {"0x7FFF", INT16_MAX },
- {"0x8000", INT16_MAX + 1 },
- {"0xFFFF", UINT16_MAX },
- {"0x00010000", UINT16_MAX + 1 },
- {"0x7FFFFFFF", INT32_MAX },
- {"0x80000000", INT32_MAX + 1U },
- {"0xFFFFFFFF", UINT32_MAX },
- {"0x0000000100000000", UINT32_MAX + 1ULL },
- {"0x7FFFFFFFFFFFFFFF", INT64_MAX },
- {"0x8000000000000000", INT64_MAX + 1ULL},
- {"0xFFFFFFFFFFFFFFFF", UINT64_MAX },
- /* check all characters */
- {"0x1234567890ABCDEF", 0x1234567890ABCDEFULL },
- {"0x1234567890abcdef", 0x1234567890ABCDEFULL },
- /* binary (no leading zeroes) */
- {"0b0", 0 },
- {"0b1111111", INT8_MAX },
- {"0b10000000", INT8_MAX + 1 },
- {"0b11111111", UINT8_MAX },
- {"0b100000000", UINT8_MAX + 1 },
- {"0b111111111111111", INT16_MAX },
- {"0b1000000000000000", INT16_MAX + 1 },
- {"0b1111111111111111", UINT16_MAX },
- {"0b10000000000000000", UINT16_MAX + 1 },
- {"0b1111111111111111111111111111111", INT32_MAX },
- {"0b10000000000000000000000000000000", INT32_MAX + 1U },
- {"0b11111111111111111111111111111111", UINT32_MAX },
- {"0b100000000000000000000000000000000", UINT32_MAX + 1ULL },
- {"0b111111111111111111111111111111111111111111111111111111111111111",
- INT64_MAX },
- {"0b1000000000000000000000000000000000000000000000000000000000000000",
- INT64_MAX + 1ULL},
- {"0b1111111111111111111111111111111111111111111111111111111111111111",
- UINT64_MAX },
- /* binary (with leading zeroes) */
- {"0b01111111", INT8_MAX },
- {"0b0000000100000000", UINT8_MAX + 1 },
- {"0b0111111111111111", INT16_MAX },
- {"0b00000000000000010000000000000000", UINT16_MAX + 1 },
- {"0b01111111111111111111111111111111", INT32_MAX },
- {"0b0000000000000000000000000000000100000000000000000000000000000000",
- UINT32_MAX + 1ULL },
- {"0b0111111111111111111111111111111111111111111111111111111111111111",
- INT64_MAX },
- /* octal */
- {"00", 0 },
- {"0177", INT8_MAX },
- {"0200", INT8_MAX + 1 },
- {"0377", UINT8_MAX },
- {"0400", UINT8_MAX + 1 },
- {"077777", INT16_MAX },
- {"0100000", INT16_MAX + 1 },
- {"0177777", UINT16_MAX },
- {"0200000", UINT16_MAX + 1 },
- {"017777777777", INT32_MAX },
- {"020000000000", INT32_MAX + 1U },
- {"037777777777", UINT32_MAX },
- {"040000000000", UINT32_MAX + 1ULL },
- {"0777777777777777777777", INT64_MAX },
- {"01000000000000000000000", INT64_MAX + 1ULL},
- {"01777777777777777777777", UINT64_MAX },
- /* check all numbers */
- {"012345670", 012345670 },
- {"076543210", 076543210 },
-};
-
-const struct num_signed_str num_valid_negative_strs[] = {
- /* deciman negative */
- {"-128", INT8_MIN },
- {"-129", INT8_MIN - 1 },
- {"-32768", INT16_MIN },
- {"-32769", INT16_MIN - 1 },
- {"-2147483648", INT32_MIN },
- {"-2147483649", INT32_MIN - 1LL },
- {"-9223372036854775808", INT64_MIN },
-};
-
-const struct num_unsigned_str num_garbage_positive_strs[] = {
- /* valid strings with garbage on the end, should still be valid */
- /* decimal */
- {"9223372036854775807\0garbage", INT64_MAX },
- {"9223372036854775807\tgarbage", INT64_MAX },
- {"9223372036854775807\rgarbage", INT64_MAX },
- {"9223372036854775807\ngarbage", INT64_MAX },
- {"9223372036854775807#garbage", INT64_MAX },
- {"9223372036854775807 garbage", INT64_MAX },
- /* hex */
- {"0x7FFFFFFFFFFFFFFF\0garbage", INT64_MAX },
- {"0x7FFFFFFFFFFFFFFF\tgarbage", INT64_MAX },
- {"0x7FFFFFFFFFFFFFFF\rgarbage", INT64_MAX },
- {"0x7FFFFFFFFFFFFFFF\ngarbage", INT64_MAX },
- {"0x7FFFFFFFFFFFFFFF#garbage", INT64_MAX },
- {"0x7FFFFFFFFFFFFFFF garbage", INT64_MAX },
- /* binary */
- {"0b1111111111111111111111111111111\0garbage", INT32_MAX },
- {"0b1111111111111111111111111111111\rgarbage", INT32_MAX },
- {"0b1111111111111111111111111111111\tgarbage", INT32_MAX },
- {"0b1111111111111111111111111111111\ngarbage", INT32_MAX },
- {"0b1111111111111111111111111111111#garbage", INT32_MAX },
- {"0b1111111111111111111111111111111 garbage", INT32_MAX },
- /* octal */
- {"01777777777777777777777\0garbage", UINT64_MAX },
- {"01777777777777777777777\rgarbage", UINT64_MAX },
- {"01777777777777777777777\tgarbage", UINT64_MAX },
- {"01777777777777777777777\ngarbage", UINT64_MAX },
- {"01777777777777777777777#garbage", UINT64_MAX },
- {"01777777777777777777777 garbage", UINT64_MAX },
-};
-
-const struct num_signed_str num_garbage_negative_strs[] = {
- /* valid strings with garbage on the end, should still be valid */
- {"-9223372036854775808\0garbage", INT64_MIN },
- {"-9223372036854775808\rgarbage", INT64_MIN },
- {"-9223372036854775808\tgarbage", INT64_MIN },
- {"-9223372036854775808\ngarbage", INT64_MIN },
- {"-9223372036854775808#garbage", INT64_MIN },
- {"-9223372036854775808 garbage", INT64_MIN },
-};
-
-const char * num_invalid_strs[] = {
- "18446744073709551616", /* out of range unsigned */
- "-9223372036854775809", /* out of range negative signed */
- "0x10000000000000000", /* out of range hex */
- /* out of range binary */
- "0b10000000000000000000000000000000000000000000000000000000000000000",
- "020000000000000000000000", /* out of range octal */
- /* wrong chars */
- "0123456239",
- "0x1234580AGE",
- "0b0111010101g001",
- "0b01110101017001",
- /* false negative numbers */
- "-12345F623",
- "-0x1234580A",
- "-0b0111010101",
- /* too long (128+ chars) */
- "0b1111000011110000111100001111000011110000111100001111000011110000"
- "1111000011110000111100001111000011110000111100001111000011110000",
- "1E3",
- "0A",
- "-B",
- "+4",
- "1.23G",
- "",
- " ",
- "#",
- "\r",
- "\t",
- "\n",
- "\0",
-};
-
-#define NUM_POSITIVE_STRS_SIZE \
- (sizeof(num_valid_positive_strs) / sizeof(num_valid_positive_strs[0]))
-#define NUM_NEGATIVE_STRS_SIZE \
- (sizeof(num_valid_negative_strs) / sizeof(num_valid_negative_strs[0]))
-#define NUM_POSITIVE_GARBAGE_STRS_SIZE \
- (sizeof(num_garbage_positive_strs) / sizeof(num_garbage_positive_strs[0]))
-#define NUM_NEGATIVE_GARBAGE_STRS_SIZE \
- (sizeof(num_garbage_negative_strs) / sizeof(num_garbage_negative_strs[0]))
-#define NUM_INVALID_STRS_SIZE \
- (sizeof(num_invalid_strs) / sizeof(num_invalid_strs[0]))
-
-
-
-static int
-can_parse_unsigned(uint64_t expected_result, enum cmdline_numtype type)
-{
- switch (type) {
- case UINT8:
- if (expected_result > UINT8_MAX)
- return 0;
- break;
- case UINT16:
- if (expected_result > UINT16_MAX)
- return 0;
- break;
- case UINT32:
- if (expected_result > UINT32_MAX)
- return 0;
- break;
- case INT8:
- if (expected_result > INT8_MAX)
- return 0;
- break;
- case INT16:
- if (expected_result > INT16_MAX)
- return 0;
- break;
- case INT32:
- if (expected_result > INT32_MAX)
- return 0;
- break;
- case INT64:
- if (expected_result > INT64_MAX)
- return 0;
- break;
- default:
- return 1;
- }
- return 1;
-}
-
-static int
-can_parse_signed(int64_t expected_result, enum cmdline_numtype type)
-{
- switch (type) {
- case UINT8:
- if (expected_result > UINT8_MAX || expected_result < 0)
- return 0;
- break;
- case UINT16:
- if (expected_result > UINT16_MAX || expected_result < 0)
- return 0;
- break;
- case UINT32:
- if (expected_result > UINT32_MAX || expected_result < 0)
- return 0;
- break;
- case UINT64:
- if (expected_result < 0)
- return 0;
- case INT8:
- if (expected_result > INT8_MAX || expected_result < INT8_MIN)
- return 0;
- break;
- case INT16:
- if (expected_result > INT16_MAX || expected_result < INT16_MIN)
- return 0;
- break;
- case INT32:
- if (expected_result > INT32_MAX || expected_result < INT32_MIN)
- return 0;
- break;
- default:
- return 1;
- }
- return 1;
-}
-
-/* test invalid parameters */
-int
-test_parse_num_invalid_param(void)
-{
- char buf[CMDLINE_TEST_BUFSIZE];
- uint32_t result;
- cmdline_parse_token_num_t token;
- int ret = 0;
-
- /* set up a token */
- token.num_data.type = UINT32;
-
- /* copy string to buffer */
- snprintf(buf, sizeof(buf), "%s",
- num_valid_positive_strs[0].str);
-
- /* try all null */
- ret = cmdline_parse_num(NULL, NULL, NULL, 0);
- if (ret != -1) {
- printf("Error: parser accepted null parameters!\n");
- return -1;
- }
-
- /* try null token */
- ret = cmdline_parse_num(NULL, buf, (void*)&result, sizeof(result));
- if (ret != -1) {
- printf("Error: parser accepted null token!\n");
- return -1;
- }
-
- /* try null buf */
- ret = cmdline_parse_num((cmdline_parse_token_hdr_t*)&token, NULL,
- (void*)&result, sizeof(result));
- if (ret != -1) {
- printf("Error: parser accepted null string!\n");
- return -1;
- }
-
- /* try null result */
- ret = cmdline_parse_num((cmdline_parse_token_hdr_t*)&token, buf,
- NULL, 0);
- if (ret == -1) {
- printf("Error: parser rejected null result!\n");
- return -1;
- }
-
- /* test help function */
- memset(&buf, 0, sizeof(buf));
-
- /* try all null */
- ret = cmdline_get_help_num(NULL, NULL, 0);
- if (ret != -1) {
- printf("Error: help function accepted null parameters!\n");
- return -1;
- }
-
- /* try null token */
- ret = cmdline_get_help_num(NULL, buf, sizeof(buf));
- if (ret != -1) {
- printf("Error: help function accepted null token!\n");
- return -1;
- }
-
- /* coverage! */
- ret = cmdline_get_help_num((cmdline_parse_token_hdr_t*)&token, buf, sizeof(buf));
- if (ret < 0) {
- printf("Error: help function failed with valid parameters!\n");
- return -1;
- }
-
- return 0;
-}
-/* test valid parameters but invalid data */
-int
-test_parse_num_invalid_data(void)
-{
- enum cmdline_numtype type;
- int ret = 0;
- unsigned i;
- char buf[CMDLINE_TEST_BUFSIZE];
- uint64_t result; /* pick largest buffer */
- cmdline_parse_token_num_t token;
-
- /* cycle through all possible parsed types */
- for (type = UINT8; type <= INT64; type++) {
- token.num_data.type = type;
-
- /* test full strings */
- for (i = 0; i < NUM_INVALID_STRS_SIZE; i++) {
-
- memset(&result, 0, sizeof(uint64_t));
- memset(&buf, 0, sizeof(buf));
-
- ret = cmdline_parse_num((cmdline_parse_token_hdr_t*)&token,
- num_invalid_strs[i], (void*)&result, sizeof(result));
- if (ret != -1) {
- /* get some info about what we are trying to parse */
- cmdline_get_help_num((cmdline_parse_token_hdr_t*)&token,
- buf, sizeof(buf));
-
- printf("Error: parsing %s as %s succeeded!\n",
- num_invalid_strs[i], buf);
- return -1;
- }
- }
- }
- return 0;
-}
-
-/* test valid parameters and data */
-int
-test_parse_num_valid(void)
-{
- int ret = 0;
- enum cmdline_numtype type;
- unsigned i;
- char buf[CMDLINE_TEST_BUFSIZE];
- uint64_t result;
- cmdline_parse_token_num_t token;
-
- /** valid strings **/
-
- /* cycle through all possible parsed types */
- for (type = UINT8; type <= INT64; type++) {
- token.num_data.type = type;
-
- /* test positive strings */
- for (i = 0; i < NUM_POSITIVE_STRS_SIZE; i++) {
- result = 0;
- memset(&buf, 0, sizeof(buf));
-
- cmdline_get_help_num((cmdline_parse_token_hdr_t*)&token,
- buf, sizeof(buf));
-
- ret = cmdline_parse_num((cmdline_parse_token_hdr_t*) &token,
- num_valid_positive_strs[i].str,
- (void*)&result, sizeof(result));
-
- /* if it should have passed but didn't, or if it should have failed but didn't */
- if ((ret < 0) == (can_parse_unsigned(num_valid_positive_strs[i].result, type) > 0)) {
- printf("Error: parser behaves unexpectedly when parsing %s as %s!\n",
- num_valid_positive_strs[i].str, buf);
- return -1;
- }
- /* check if result matches what it should have matched
- * since unsigned numbers don't care about number of bits, we can just convert
- * everything to uint64_t without any worries. */
- if (ret > 0 && num_valid_positive_strs[i].result != result) {
- printf("Error: parsing %s as %s failed: result mismatch!\n",
- num_valid_positive_strs[i].str, buf);
- return -1;
- }
- }
-
- /* test negative strings */
- for (i = 0; i < NUM_NEGATIVE_STRS_SIZE; i++) {
- result = 0;
- memset(&buf, 0, sizeof(buf));
-
- cmdline_get_help_num((cmdline_parse_token_hdr_t*)&token,
- buf, sizeof(buf));
-
- ret = cmdline_parse_num((cmdline_parse_token_hdr_t*) &token,
- num_valid_negative_strs[i].str,
- (void*)&result, sizeof(result));
-
- /* if it should have passed but didn't, or if it should have failed but didn't */
- if ((ret < 0) == (can_parse_signed(num_valid_negative_strs[i].result, type) > 0)) {
- printf("Error: parser behaves unexpectedly when parsing %s as %s!\n",
- num_valid_negative_strs[i].str, buf);
- return -1;
- }
- /* check if result matches what it should have matched
- * the result is signed in this case, so we have to account for that */
- if (ret > 0) {
- /* detect negative */
- switch (type) {
- case INT8:
- result = (int8_t) result;
- break;
- case INT16:
- result = (int16_t) result;
- break;
- case INT32:
- result = (int32_t) result;
- break;
- default:
- break;
- }
- if (num_valid_negative_strs[i].result == (int64_t) result)
- continue;
- printf("Error: parsing %s as %s failed: result mismatch!\n",
- num_valid_negative_strs[i].str, buf);
- return -1;
- }
- }
- }
-
- /** garbage strings **/
-
- /* cycle through all possible parsed types */
- for (type = UINT8; type <= INT64; type++) {
- token.num_data.type = type;
-
- /* test positive garbage strings */
- for (i = 0; i < NUM_POSITIVE_GARBAGE_STRS_SIZE; i++) {
- result = 0;
- memset(&buf, 0, sizeof(buf));
-
- cmdline_get_help_num((cmdline_parse_token_hdr_t*)&token,
- buf, sizeof(buf));
-
- ret = cmdline_parse_num((cmdline_parse_token_hdr_t*) &token,
- num_garbage_positive_strs[i].str,
- (void*)&result, sizeof(result));
-
- /* if it should have passed but didn't, or if it should have failed but didn't */
- if ((ret < 0) == (can_parse_unsigned(num_garbage_positive_strs[i].result, type) > 0)) {
- printf("Error: parser behaves unexpectedly when parsing %s as %s!\n",
- num_garbage_positive_strs[i].str, buf);
- return -1;
- }
- /* check if result matches what it should have matched
- * since unsigned numbers don't care about number of bits, we can just convert
- * everything to uint64_t without any worries. */
- if (ret > 0 && num_garbage_positive_strs[i].result != result) {
- printf("Error: parsing %s as %s failed: result mismatch!\n",
- num_garbage_positive_strs[i].str, buf);
- return -1;
- }
- }
-
- /* test negative strings */
- for (i = 0; i < NUM_NEGATIVE_GARBAGE_STRS_SIZE; i++) {
- result = 0;
- memset(&buf, 0, sizeof(buf));
-
- cmdline_get_help_num((cmdline_parse_token_hdr_t*)&token,
- buf, sizeof(buf));
-
- ret = cmdline_parse_num((cmdline_parse_token_hdr_t*) &token,
- num_garbage_negative_strs[i].str,
- (void*)&result, sizeof(result));
-
- /* if it should have passed but didn't, or if it should have failed but didn't */
- if ((ret < 0) == (can_parse_signed(num_garbage_negative_strs[i].result, type) > 0)) {
- printf("Error: parser behaves unexpectedly when parsing %s as %s!\n",
- num_garbage_negative_strs[i].str, buf);
- return -1;
- }
- /* check if result matches what it should have matched
- * the result is signed in this case, so we have to account for that */
- if (ret > 0) {
- /* detect negative */
- switch (type) {
- case INT8:
- if (result & (INT8_MAX + 1))
- result |= 0xFFFFFFFFFFFFFF00ULL;
- break;
- case INT16:
- if (result & (INT16_MAX + 1))
- result |= 0xFFFFFFFFFFFF0000ULL;
- break;
- case INT32:
- if (result & (INT32_MAX + 1ULL))
- result |= 0xFFFFFFFF00000000ULL;
- break;
- default:
- break;
- }
- if (num_garbage_negative_strs[i].result == (int64_t) result)
- continue;
- printf("Error: parsing %s as %s failed: result mismatch!\n",
- num_garbage_negative_strs[i].str, buf);
- return -1;
- }
- }
- }
-
- memset(&buf, 0, sizeof(buf));
-
- /* coverage! */
- cmdline_get_help_num((cmdline_parse_token_hdr_t*)&token,
- buf, sizeof(buf));
-
- return 0;
-}
Code Review / deb_dpdk.git / blobdiff