sscanf.c 5.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * Copyright (c) 2002, Uwe Bonnes
  4. * Copyright (c) 2001-2004, Roger Dingledine.
  5. * Copyright (c) 2004-2006, Roger Dingledine, Nick Mathewson.
  6. * Copyright (c) 2007-2016, The Tor Project, Inc.
  7. * Copyright (c) 2020, EPAM Systems Inc.
  8. *
  9. * Unit tests for sscanf() function
  10. */
  11. #include <common.h>
  12. #include <command.h>
  13. #include <log.h>
  14. #include <test/lib.h>
  15. #include <test/test.h>
  16. #include <test/ut.h>
  17. #define EOF -1
  18. /**
  19. * lib_sscanf() - unit test for sscanf()
  20. * @uts: unit test state
  21. *
  22. * Test sscanf() with varied parameters in different combinations passed
  23. * as arguments.
  24. *
  25. * Return: 0 - success
  26. * 1 - failure
  27. */
  28. static int lib_sscanf(struct unit_test_state *uts)
  29. {
  30. char buffer[100], buffer1[100];
  31. int result, ret;
  32. static const char pname[] = " Hello World!\n";
  33. int hour = 21, min = 59, sec = 20;
  34. int number, number_so_far;
  35. unsigned int u1, u2, u3;
  36. char s1[20], s2[10], s3[10], ch;
  37. int r, int1, int2;
  38. long lng1;
  39. /* check EOF */
  40. strcpy(buffer, "");
  41. ret = sscanf(buffer, "%d", &result);
  42. ut_asserteq(ret, EOF);
  43. /* check %x */
  44. strcpy(buffer, "0x519");
  45. ut_asserteq(sscanf(buffer, "%x", &result), 1);
  46. ut_asserteq(result, 0x519);
  47. strcpy(buffer, "0x51a");
  48. ut_asserteq(sscanf(buffer, "%x", &result), 1);
  49. ut_asserteq(result, 0x51a);
  50. strcpy(buffer, "0x51g");
  51. ut_asserteq(sscanf(buffer, "%x", &result), 1);
  52. ut_asserteq(result, 0x51);
  53. /* check strings */
  54. ret = sprintf(buffer, " %s", pname);
  55. ret = sscanf(buffer, "%*c%[^\n]", buffer1);
  56. ut_asserteq(ret, 1);
  57. ut_asserteq(strncmp(pname, buffer1, strlen(buffer1)), 0);
  58. /* check digits */
  59. ret = sprintf(buffer, "%d:%d:%d", hour, min, sec);
  60. ret = sscanf(buffer, "%d%n", &number, &number_so_far);
  61. ut_asserteq(ret, 1);
  62. ut_asserteq(number, hour);
  63. ut_asserteq(number_so_far, 2);
  64. ret = sscanf(buffer + 2, "%*c%n", &number_so_far);
  65. ut_asserteq(ret, 0);
  66. ut_asserteq(number_so_far, 1);
  67. /* Check %i */
  68. strcpy(buffer, "123");
  69. ret = sscanf(buffer, "%i", &result);
  70. ut_asserteq(ret, 1);
  71. ut_asserteq(result, 123);
  72. ret = sscanf(buffer, "%d", &result);
  73. ut_asserteq(ret, 1);
  74. ut_asserteq(result, 123);
  75. ut_asserteq(0, sscanf("hello world", "hello world"));
  76. ut_asserteq(0, sscanf("hello world", "good bye"));
  77. /* Excess data */
  78. ut_asserteq(0, sscanf("hello 3", "%u", &u1)); /* have to match the start */
  79. ut_asserteq(1, sscanf("3 hello", "%u", &u1)); /* but trailing is alright */
  80. /* Numbers (ie. %u) */
  81. ut_asserteq(0, sscanf("hello world 3", "hello worlb %u", &u1)); /* d vs b */
  82. ut_asserteq(1, sscanf("12345", "%u", &u1));
  83. ut_asserteq(12345u, u1);
  84. ut_asserteq(1, sscanf("0", "%u", &u1));
  85. ut_asserteq(0u, u1);
  86. ut_asserteq(1, sscanf("0000", "%u", &u2));
  87. ut_asserteq(0u, u2);
  88. ut_asserteq(0, sscanf("A", "%u", &u1)); /* bogus number */
  89. /* Numbers with size (eg. %2u) */
  90. ut_asserteq(2, sscanf("123456", "%2u%u", &u1, &u2));
  91. ut_asserteq(12u, u1);
  92. ut_asserteq(3456u, u2);
  93. ut_asserteq(1, sscanf("123456", "%8u", &u1));
  94. ut_asserteq(123456u, u1);
  95. ut_asserteq(1, sscanf("123457 ", "%8u", &u1));
  96. ut_asserteq(123457u, u1);
  97. ut_asserteq(3, sscanf("!12:3:456", "!%2u:%2u:%3u", &u1, &u2, &u3));
  98. ut_asserteq(12u, u1);
  99. ut_asserteq(3u, u2);
  100. ut_asserteq(456u, u3);
  101. ut_asserteq(3, sscanf("67:8:099", "%2u:%2u:%3u", &u1, &u2, &u3)); /* 0s */
  102. ut_asserteq(67u, u1);
  103. ut_asserteq(8u, u2);
  104. ut_asserteq(99u, u3);
  105. /* Arbitrary amounts of 0-padding are okay */
  106. ut_asserteq(3, sscanf("12:03:000000000000000099", "%2u:%2u:%u", &u1, &u2, &u3));
  107. ut_asserteq(12u, u1);
  108. ut_asserteq(3u, u2);
  109. ut_asserteq(99u, u3);
  110. /* Hex (ie. %x) */
  111. ut_asserteq(3, sscanf("1234 02aBcdEf ff", "%x %x %x", &u1, &u2, &u3));
  112. ut_asserteq(0x1234, u1);
  113. ut_asserteq(0x2ABCDEF, u2);
  114. ut_asserteq(0xFF, u3);
  115. /* Width works on %x */
  116. ut_asserteq(3, sscanf("f00dcafe444", "%4x%4x%u", &u1, &u2, &u3));
  117. ut_asserteq(0xf00d, u1);
  118. ut_asserteq(0xcafe, u2);
  119. ut_asserteq(444, u3);
  120. /* Literal '%' (ie. '%%') */
  121. ut_asserteq(1, sscanf("99% fresh", "%3u%% fresh", &u1));
  122. ut_asserteq(99, u1);
  123. ut_asserteq(0, sscanf("99 fresh", "%% %3u %s", &u1, s1));
  124. ut_asserteq(1, sscanf("99 fresh", "%3u%% %s", &u1, s1));
  125. ut_asserteq(2, sscanf("99 fresh", "%3u %5s %%", &u1, s1));
  126. ut_asserteq(99, u1);
  127. ut_asserteq_str(s1, "fresh");
  128. ut_asserteq(1, sscanf("% boo", "%% %3s", s1));
  129. ut_asserteq_str("boo", s1);
  130. /* Strings (ie. %s) */
  131. ut_asserteq(2, sscanf("hello", "%3s%7s", s1, s2));
  132. ut_asserteq_str(s1, "hel");
  133. ut_asserteq_str(s2, "lo");
  134. ut_asserteq(2, sscanf("WD40", "%2s%u", s3, &u1)); /* %s%u */
  135. ut_asserteq_str(s3, "WD");
  136. ut_asserteq(40, u1);
  137. ut_asserteq(2, sscanf("WD40", "%3s%u", s3, &u1)); /* %s%u */
  138. ut_asserteq_str(s3, "WD4");
  139. ut_asserteq(0, u1);
  140. ut_asserteq(2, sscanf("76trombones", "%6u%9s", &u1, s1)); /* %u%s */
  141. ut_asserteq(76, u1);
  142. ut_asserteq_str(s1, "trombones");
  143. ut_asserteq(3, sscanf("1.2.3", "%u.%u.%u%c", &u1, &u2, &u3, &ch));
  144. ut_asserteq(4, sscanf("1.2.3 foobar", "%u.%u.%u%c", &u1, &u2, &u3, &ch));
  145. ut_asserteq(' ', ch);
  146. r = sscanf("12345 -67890 -1", "%d %ld %d", &int1, &lng1, &int2);
  147. ut_asserteq(r, 3);
  148. ut_asserteq(int1, 12345);
  149. ut_asserteq(lng1, -67890);
  150. ut_asserteq(int2, -1);
  151. return 0;
  152. }
  153. LIB_TEST(lib_sscanf, 0);