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 322692 2017-08-19 09:38:43Z 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, handler */
113ATF_TC_WITHOUT_HEAD(n_gt_smax);
114ATF_TC_BODY(n_gt_smax, tc)
115{
116	char b[3] = {1, 2, 3};
117
118	e = 0;
119	m = NULL;
120	set_constraint_handler_s(h);
121	assert(memset_s(&b[0], 1, 9, 3) != 0);
122	assert(e > 0);
123	assert(strcmp(m, "memset_s : n > smax") == 0);
124	assert(b[0] == 9);
125	assert(b[1] == 2);
126	assert(b[2] == 3);
127}
128
129/* smax > rmax, handler */
130ATF_TC_WITHOUT_HEAD(smax_gt_rmax_handler);
131ATF_TC_BODY(smax_gt_rmax_handler, tc)
132{
133	char b;
134
135	e = 0;
136	m = NULL;
137	set_constraint_handler_s(h);
138	assert(memset_s(&b, RSIZE_MAX + 1, 1, 1) != 0);
139	assert(e > 0);
140	assert(strcmp(m, "memset_s : smax > RSIZE_MAX") == 0);
141}
142
143/* smax < 0, handler */
144ATF_TC_WITHOUT_HEAD(smax_lt_zero_handler);
145ATF_TC_BODY(smax_lt_zero_handler, tc)
146{
147	char b;
148
149	e = 0;
150	m = NULL;
151	set_constraint_handler_s(h);
152	assert(memset_s(&b, -1, 1, 1) != 0);
153	assert(e > 0);
154	assert(strcmp(m, "memset_s : smax > RSIZE_MAX") == 0);
155}
156
157/* n > rmax, handler */
158ATF_TC_WITHOUT_HEAD(n_gt_rmax_handler);
159ATF_TC_BODY(n_gt_rmax_handler, tc)
160{
161	char b;
162
163	e = 0;
164	m = NULL;
165	set_constraint_handler_s(h);
166	assert(memset_s(&b, 1, 1, RSIZE_MAX + 1) != 0);
167	assert(e > 0);
168	assert(strcmp(m, "memset_s : n > RSIZE_MAX") == 0);
169}
170
171/* n < 0, handler */
172ATF_TC_WITHOUT_HEAD(n_lt_zero_handler);
173ATF_TC_BODY(n_lt_zero_handler, tc)
174{
175	char b;
176
177	e = 0;
178	m = NULL;
179	set_constraint_handler_s(h);
180	assert(memset_s(&b, 1, 1, -1) != 0);
181	assert(e > 0);
182	assert(strcmp(m, "memset_s : n > RSIZE_MAX") == 0);
183}
184
185ATF_TP_ADD_TCS(tp)
186{
187	ATF_TP_ADD_TC(tp, null_ptr);
188	ATF_TP_ADD_TC(tp, smax_gt_rmax);
189	ATF_TP_ADD_TC(tp, smax_lt_zero);
190	ATF_TP_ADD_TC(tp, normal);
191	ATF_TP_ADD_TC(tp, n_gt_rmax);
192	ATF_TP_ADD_TC(tp, n_lt_zero);
193	ATF_TP_ADD_TC(tp, n_gt_smax);
194	ATF_TP_ADD_TC(tp, n_lt_smax);
195	ATF_TP_ADD_TC(tp, smax_gt_rmax_handler);
196	ATF_TP_ADD_TC(tp, smax_lt_zero_handler);
197	ATF_TP_ADD_TC(tp, n_gt_rmax_handler);
198	ATF_TP_ADD_TC(tp, n_lt_zero_handler);
199	return (atf_no_error());
200}
201