memset_s_test.c revision 317342 
1/*-
2 * Copyright (c) 2017 Juniper Networks.  All rights reserved.
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
6 * are met:
7 * 1. Redistributions of source code must retain the above copyright
8 *    notice, this list of conditions and the following disclaimer.
9 * 2. Redistributions in binary form must reproduce the above copyright
10 *    notice, this list of conditions and the following disclaimer in the
11 *    documentation and/or other materials provided with the distribution.
12 *
13 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
14 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
16 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
17 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
18 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
19 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
20 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
21 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
22 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
23 * SUCH DAMAGE.
24 */
25
26#include <sys/cdefs.h>
27__FBSDID("$FreeBSD: stable/11/lib/libc/tests/string/memset_s_test.c 317342 2017-04-23 20:32:46Z kib $");
28
29#include <assert.h>
30#include <stdint.h>
31#include <stdlib.h>
32#include <string.h>
33
34#include <atf-c.h>
35
36static errno_t e;
37static const char * restrict m;
38
39void
40h(const char * restrict msg, void * restrict ptr __unused, errno_t error)
41{
42	e = error;
43	m = msg;
44}
45
46/* null ptr */
47ATF_TC_WITHOUT_HEAD(null_ptr);
48ATF_TC_BODY(null_ptr, tc)
49{
50	assert(memset_s(0, 1, 1, 1) != 0);
51}
52
53/* smax > rmax */
54ATF_TC_WITHOUT_HEAD(smax_gt_rmax);
55ATF_TC_BODY(smax_gt_rmax, tc)
56{
57	char b;
58
59	assert(memset_s(&b, RSIZE_MAX + 1, 1, 1) != 0);
60}
61
62/* smax < 0 */
63ATF_TC_WITHOUT_HEAD(smax_lt_zero);
64ATF_TC_BODY(smax_lt_zero, tc)
65{
66	char b;
67
68	assert(memset_s(&b, -1, 1, 1) != 0);
69}
70
71/* normal */
72ATF_TC_WITHOUT_HEAD(normal);
73ATF_TC_BODY(normal, tc)
74{
75	char b;
76
77	b = 3;
78	assert(memset_s(&b, 1, 5, 1) == 0);
79	assert(b == 5);
80}
81
82/* n > rmax */
83ATF_TC_WITHOUT_HEAD(n_gt_rmax);
84ATF_TC_BODY(n_gt_rmax, tc)
85{
86	char b;
87
88	assert(memset_s(&b, 1, 1, RSIZE_MAX + 1) != 0);
89}
90
91/* n < 0 */
92ATF_TC_WITHOUT_HEAD(n_lt_zero);
93ATF_TC_BODY(n_lt_zero, tc)
94{
95	char b;
96
97	assert(memset_s(&b, 1, 1, -1) != 0);
98}
99
100/* n < smax */
101ATF_TC_WITHOUT_HEAD(n_lt_smax);
102ATF_TC_BODY(n_lt_smax, tc)
103{
104	char b[3] = {1, 2, 3};
105
106	assert(memset_s(&b[0], 3, 9, 1) == 0);
107	assert(b[0] == 9);
108	assert(b[1] == 2);
109	assert(b[2] == 3);
110}
111
112/* n > smax */
113ATF_TC_WITHOUT_HEAD(n_gt_smax);
114ATF_TC_BODY(n_gt_smax, tc)
115{
116	char b[3] = {1, 2, 3};
117
118	assert(memset_s(&b[0], 1, 9, 3) == 0);
119	assert(b[0] == 9);
120	assert(b[1] == 2);
121	assert(b[2] == 3);
122}
123
124/* smax > rmax, handler */
125ATF_TC_WITHOUT_HEAD(smax_gt_rmax_handler);
126ATF_TC_BODY(smax_gt_rmax_handler, tc)
127{
128	char b;
129
130	e = 0;
131	m = NULL;
132	set_constraint_handler_s(h);
133	assert(memset_s(&b, RSIZE_MAX + 1, 1, 1) != 0);
134	assert(e > 0);
135	assert(strcmp(m, "memset_s : smax > RSIZE_MAX") == 0);
136}
137
138/* smax < 0, handler */
139ATF_TC_WITHOUT_HEAD(smax_lt_zero_handler);
140ATF_TC_BODY(smax_lt_zero_handler, tc)
141{
142	char b;
143
144	e = 0;
145	m = NULL;
146	set_constraint_handler_s(h);
147	assert(memset_s(&b, -1, 1, 1) != 0);
148	assert(e > 0);
149	assert(strcmp(m, "memset_s : smax > RSIZE_MAX") == 0);
150}
151
152/* n > rmax, handler */
153ATF_TC_WITHOUT_HEAD(n_gt_rmax_handler);
154ATF_TC_BODY(n_gt_rmax_handler, tc)
155{
156	char b;
157
158	e = 0;
159	m = NULL;
160	set_constraint_handler_s(h);
161	assert(memset_s(&b, 1, 1, RSIZE_MAX + 1) != 0);
162	assert(e > 0);
163	assert(strcmp(m, "memset_s : n > RSIZE_MAX") == 0);
164}
165
166/* n < 0, handler */
167ATF_TC_WITHOUT_HEAD(n_lt_zero_handler);
168ATF_TC_BODY(n_lt_zero_handler, tc)
169{
170	char b;
171
172	e = 0;
173	m = NULL;
174	set_constraint_handler_s(h);
175	assert(memset_s(&b, 1, 1, -1) != 0);
176	assert(e > 0);
177	assert(strcmp(m, "memset_s : n > RSIZE_MAX") == 0);
178}
179
180ATF_TP_ADD_TCS(tp)
181{
182	ATF_TP_ADD_TC(tp, null_ptr);
183	ATF_TP_ADD_TC(tp, smax_gt_rmax);
184	ATF_TP_ADD_TC(tp, smax_lt_zero);
185	ATF_TP_ADD_TC(tp, normal);
186	ATF_TP_ADD_TC(tp, n_gt_rmax);
187	ATF_TP_ADD_TC(tp, n_lt_zero);
188	ATF_TP_ADD_TC(tp, n_gt_smax);
189	ATF_TP_ADD_TC(tp, n_lt_smax);
190	ATF_TP_ADD_TC(tp, smax_gt_rmax_handler);
191	ATF_TP_ADD_TC(tp, smax_lt_zero_handler);
192	ATF_TP_ADD_TC(tp, n_gt_rmax_handler);
193	ATF_TP_ADD_TC(tp, n_lt_zero_handler);
194	return (atf_no_error());
195}
196