• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1  /*
2   * Copyright © 2012 Intel Corporation
3   *
4   * Permission is hereby granted, free of charge, to any person obtaining a
5   * copy of this software and associated documentation files (the "Software"),
6   * to deal in the Software without restriction, including without limitation
7   * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8   * and/or sell copies of the Software, and to permit persons to whom the
9   * Software is furnished to do so, subject to the following conditions:
10   *
11   * The above copyright notice and this permission notice (including the next
12   * paragraph) shall be included in all copies or substantial portions of the
13   * Software.
14   *
15   * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16   * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17   * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
18   * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19   * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20   * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
21   * DEALINGS IN THE SOFTWARE.
22   */
23  #include <gtest/gtest.h>
24  #include "main/compiler.h"
25  #include "main/mtypes.h"
26  #include "main/macros.h"
27  #include "ralloc.h"
28  #include "uniform_initializer_utils.h"
29  
30  namespace linker {
31  extern void
32  copy_constant_to_storage(union gl_constant_value *storage,
33  			 const ir_constant *val,
34  			 const enum glsl_base_type base_type,
35  			 const unsigned int elements);
36  }
37  
38  class copy_constant_to_storage : public ::testing::Test {
39  public:
40     void int_test(unsigned rows);
41     void uint_test(unsigned rows);
42     void bool_test(unsigned rows);
43     void sampler_test();
44     void float_test(unsigned columns, unsigned rows);
45  
46     virtual void SetUp();
47     virtual void TearDown();
48  
49     gl_constant_value storage[17];
50     void *mem_ctx;
51  };
52  
53  void
SetUp()54  copy_constant_to_storage::SetUp()
55  {
56     this->mem_ctx = ralloc_context(NULL);
57  }
58  
59  void
TearDown()60  copy_constant_to_storage::TearDown()
61  {
62     ralloc_free(this->mem_ctx);
63     this->mem_ctx = NULL;
64  }
65  
66  void
int_test(unsigned rows)67  copy_constant_to_storage::int_test(unsigned rows)
68  {
69     ir_constant *val;
70     generate_data(mem_ctx, GLSL_TYPE_INT, 1, rows, val);
71  
72     const unsigned red_zone_size = Elements(storage) - val->type->components();
73     fill_storage_array_with_sentinels(storage,
74  				     val->type->components(),
75  				     red_zone_size);
76  
77     linker::copy_constant_to_storage(storage,
78  				    val,
79  				    val->type->base_type,
80  				    val->type->components());
81  
82     verify_data(storage, 0, val, red_zone_size);
83  }
84  
85  void
uint_test(unsigned rows)86  copy_constant_to_storage::uint_test(unsigned rows)
87  {
88     ir_constant *val;
89     generate_data(mem_ctx, GLSL_TYPE_UINT, 1, rows, val);
90  
91     const unsigned red_zone_size = Elements(storage) - val->type->components();
92     fill_storage_array_with_sentinels(storage,
93  				     val->type->components(),
94  				     red_zone_size);
95  
96     linker::copy_constant_to_storage(storage,
97  				    val,
98  				    val->type->base_type,
99  				    val->type->components());
100  
101     verify_data(storage, 0, val, red_zone_size);
102  }
103  
104  void
float_test(unsigned columns,unsigned rows)105  copy_constant_to_storage::float_test(unsigned columns, unsigned rows)
106  {
107     ir_constant *val;
108     generate_data(mem_ctx, GLSL_TYPE_FLOAT, columns, rows, val);
109  
110     const unsigned red_zone_size = Elements(storage) - val->type->components();
111     fill_storage_array_with_sentinels(storage,
112  				     val->type->components(),
113  				     red_zone_size);
114  
115     linker::copy_constant_to_storage(storage,
116  				    val,
117  				    val->type->base_type,
118  				    val->type->components());
119  
120     verify_data(storage, 0, val, red_zone_size);
121  }
122  
123  void
bool_test(unsigned rows)124  copy_constant_to_storage::bool_test(unsigned rows)
125  {
126     ir_constant *val;
127     generate_data(mem_ctx, GLSL_TYPE_BOOL, 1, rows, val);
128  
129     const unsigned red_zone_size = Elements(storage) - val->type->components();
130     fill_storage_array_with_sentinels(storage,
131  				     val->type->components(),
132  				     red_zone_size);
133  
134     linker::copy_constant_to_storage(storage,
135  				    val,
136  				    val->type->base_type,
137  				    val->type->components());
138  
139     verify_data(storage, 0, val, red_zone_size);
140  }
141  
142  /**
143   * The only difference between this test and int_test is that the base type
144   * passed to \c linker::copy_constant_to_storage is hard-coded to \c
145   * GLSL_TYPE_SAMPLER instead of using the base type from the constant.
146   */
147  void
sampler_test(void)148  copy_constant_to_storage::sampler_test(void)
149  {
150     ir_constant *val;
151     generate_data(mem_ctx, GLSL_TYPE_INT, 1, 1, val);
152  
153     const unsigned red_zone_size = Elements(storage) - val->type->components();
154     fill_storage_array_with_sentinels(storage,
155  				     val->type->components(),
156  				     red_zone_size);
157  
158     linker::copy_constant_to_storage(storage,
159  				    val,
160  				    GLSL_TYPE_SAMPLER,
161  				    val->type->components());
162  
163     verify_data(storage, 0, val, red_zone_size);
164  }
165  
TEST_F(copy_constant_to_storage,bool_uniform)166  TEST_F(copy_constant_to_storage, bool_uniform)
167  {
168     bool_test(1);
169  }
170  
TEST_F(copy_constant_to_storage,bvec2_uniform)171  TEST_F(copy_constant_to_storage, bvec2_uniform)
172  {
173     bool_test(2);
174  }
175  
TEST_F(copy_constant_to_storage,bvec3_uniform)176  TEST_F(copy_constant_to_storage, bvec3_uniform)
177  {
178     bool_test(3);
179  }
180  
TEST_F(copy_constant_to_storage,bvec4_uniform)181  TEST_F(copy_constant_to_storage, bvec4_uniform)
182  {
183     bool_test(4);
184  }
185  
TEST_F(copy_constant_to_storage,int_uniform)186  TEST_F(copy_constant_to_storage, int_uniform)
187  {
188     int_test(1);
189  }
190  
TEST_F(copy_constant_to_storage,ivec2_uniform)191  TEST_F(copy_constant_to_storage, ivec2_uniform)
192  {
193     int_test(2);
194  }
195  
TEST_F(copy_constant_to_storage,ivec3_uniform)196  TEST_F(copy_constant_to_storage, ivec3_uniform)
197  {
198     int_test(3);
199  }
200  
TEST_F(copy_constant_to_storage,ivec4_uniform)201  TEST_F(copy_constant_to_storage, ivec4_uniform)
202  {
203     int_test(4);
204  }
205  
TEST_F(copy_constant_to_storage,uint_uniform)206  TEST_F(copy_constant_to_storage, uint_uniform)
207  {
208     uint_test(1);
209  }
210  
TEST_F(copy_constant_to_storage,uvec2_uniform)211  TEST_F(copy_constant_to_storage, uvec2_uniform)
212  {
213     uint_test(2);
214  }
215  
TEST_F(copy_constant_to_storage,uvec3_uniform)216  TEST_F(copy_constant_to_storage, uvec3_uniform)
217  {
218     uint_test(3);
219  }
220  
TEST_F(copy_constant_to_storage,uvec4_uniform)221  TEST_F(copy_constant_to_storage, uvec4_uniform)
222  {
223     uint_test(4);
224  }
225  
TEST_F(copy_constant_to_storage,float_uniform)226  TEST_F(copy_constant_to_storage, float_uniform)
227  {
228     float_test(1, 1);
229  }
230  
TEST_F(copy_constant_to_storage,vec2_uniform)231  TEST_F(copy_constant_to_storage, vec2_uniform)
232  {
233     float_test(1, 2);
234  }
235  
TEST_F(copy_constant_to_storage,vec3_uniform)236  TEST_F(copy_constant_to_storage, vec3_uniform)
237  {
238     float_test(1, 3);
239  }
240  
TEST_F(copy_constant_to_storage,vec4_uniform)241  TEST_F(copy_constant_to_storage, vec4_uniform)
242  {
243     float_test(1, 4);
244  }
245  
TEST_F(copy_constant_to_storage,mat2x2_uniform)246  TEST_F(copy_constant_to_storage, mat2x2_uniform)
247  {
248     float_test(2, 2);
249  }
250  
TEST_F(copy_constant_to_storage,mat2x3_uniform)251  TEST_F(copy_constant_to_storage, mat2x3_uniform)
252  {
253     float_test(2, 3);
254  }
255  
TEST_F(copy_constant_to_storage,mat2x4_uniform)256  TEST_F(copy_constant_to_storage, mat2x4_uniform)
257  {
258     float_test(2, 4);
259  }
260  
TEST_F(copy_constant_to_storage,mat3x2_uniform)261  TEST_F(copy_constant_to_storage, mat3x2_uniform)
262  {
263     float_test(3, 2);
264  }
265  
TEST_F(copy_constant_to_storage,mat3x3_uniform)266  TEST_F(copy_constant_to_storage, mat3x3_uniform)
267  {
268     float_test(3, 3);
269  }
270  
TEST_F(copy_constant_to_storage,mat3x4_uniform)271  TEST_F(copy_constant_to_storage, mat3x4_uniform)
272  {
273     float_test(3, 4);
274  }
275  
TEST_F(copy_constant_to_storage,mat4x2_uniform)276  TEST_F(copy_constant_to_storage, mat4x2_uniform)
277  {
278     float_test(4, 2);
279  }
280  
TEST_F(copy_constant_to_storage,mat4x3_uniform)281  TEST_F(copy_constant_to_storage, mat4x3_uniform)
282  {
283     float_test(4, 3);
284  }
285  
TEST_F(copy_constant_to_storage,mat4x4_uniform)286  TEST_F(copy_constant_to_storage, mat4x4_uniform)
287  {
288     float_test(4, 4);
289  }
290  
TEST_F(copy_constant_to_storage,sampler_uniform)291  TEST_F(copy_constant_to_storage, sampler_uniform)
292  {
293     sampler_test();
294  }
295