Skip to content
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.

Commit 4b38c4e

Browse files
tannergoodingtannergooding
committedJan 26, 2022
Adding NFloat tests (p1)
1 parent 5e25e30 commit 4b38c4e

File tree

1 file changed

+674
-21
lines changed
  • src/libraries/System.Runtime.InteropServices/tests/System.Runtime.InteropServices.UnitTests/System/Runtime/InteropServices

1 file changed

+674
-21
lines changed
 

‎src/libraries/System.Runtime.InteropServices/tests/System.Runtime.InteropServices.UnitTests/System/Runtime/InteropServices/NFloatTests.cs

+674-21
Original file line numberDiff line numberDiff line change
@@ -15,36 +15,700 @@ public class NFloatTests
1515
[Fact]
1616
public void Ctor_Empty()
1717
{
18-
NFloat value = new NFloat();
19-
Assert.Equal(0, value.Value);
18+
NFloat result = new NFloat();
19+
Assert.Equal(0, result.Value);
2020
}
2121

2222
[Fact]
2323
public void Ctor_Float()
2424
{
25-
NFloat value = new NFloat(42.0f);
26-
Assert.Equal(42.0, value.Value);
25+
NFloat result = new NFloat(42.0f);
26+
Assert.Equal(42.0, result.Value);
2727
}
2828

2929
[Fact]
3030
public void Ctor_Double()
3131
{
32-
NFloat value = new NFloat(42.0);
33-
Assert.Equal(42.0, value.Value);
32+
NFloat result = new NFloat(42.0);
33+
Assert.Equal(42.0, result.Value);
3434
}
3535

3636
[ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.Is32BitProcess))]
3737
public void Ctor_Double_OutOfRange()
3838
{
39-
NFloat value = new NFloat(double.MaxValue);
40-
Assert.Equal((double)(float)double.MaxValue, value.Value);
39+
NFloat result = new NFloat(double.MaxValue);
40+
Assert.Equal(float.PositiveInfinity, result.Value);
4141
}
4242

4343
[ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.Is64BitProcess))]
4444
public void Ctor_Double_LargeValue()
4545
{
46-
NFloat value = new NFloat(double.MaxValue);
47-
Assert.Equal(double.MaxValue, value.Value);
46+
NFloat result = new NFloat(double.MaxValue);
47+
Assert.Equal(double.MaxValue, result.Value);
48+
}
49+
50+
[Fact]
51+
public void Epsilon()
52+
{
53+
NFloat result = NFloat.Epsilon;
54+
55+
if (Environment.Is64BitProcess)
56+
{
57+
Assert.Equal(double.Epsilon, result.Value);
58+
}
59+
else
60+
{
61+
Assert.Equal(float.Epsilon, result.Value);
62+
}
63+
}
64+
65+
[Fact]
66+
public void MaxValue()
67+
{
68+
NFloat result = NFloat.MaxValue;
69+
70+
if (Environment.Is64BitProcess)
71+
{
72+
Assert.Equal(double.MaxValue, result.Value);
73+
}
74+
else
75+
{
76+
Assert.Equal(float.MaxValue, result.Value);
77+
}
78+
}
79+
80+
[Fact]
81+
public void MinValue()
82+
{
83+
NFloat result = NFloat.MinValue;
84+
85+
if (Environment.Is64BitProcess)
86+
{
87+
Assert.Equal(double.MinValue, result.Value);
88+
}
89+
else
90+
{
91+
Assert.Equal(float.MinValue, result.Value);
92+
}
93+
}
94+
95+
[Fact]
96+
public void NaN()
97+
{
98+
NFloat result = NFloat.NaN;
99+
Assert.True(double.IsNaN(result.Value));
100+
}
101+
102+
[Fact]
103+
public void NegativeInfinity()
104+
{
105+
NFloat result = NFloat.NegativeInfinity;
106+
107+
if (Environment.Is64BitProcess)
108+
{
109+
Assert.Equal(double.NegativeInfinity, result.Value);
110+
}
111+
else
112+
{
113+
Assert.Equal(float.NegativeInfinity, result.Value);
114+
}
115+
}
116+
117+
[Fact]
118+
public void PositiveInfinity()
119+
{
120+
NFloat result = NFloat.PositiveInfinity;
121+
122+
if (Environment.Is64BitProcess)
123+
{
124+
Assert.Equal(double.PositiveInfinity, result.Value);
125+
}
126+
else
127+
{
128+
Assert.Equal(float.PositiveInfinity, result.Value);
129+
}
130+
}
131+
132+
[Fact]
133+
public unsafe void Size()
134+
{
135+
int size = PlatformDetection.Is32BitProcess ? 4 : 8;
136+
#pragma warning disable xUnit2000 // The value under test here is the sizeof expression
137+
Assert.Equal(size, sizeof(NFloat));
138+
#pragma warning restore xUnit2000
139+
Assert.Equal(size, Marshal.SizeOf<NFloat>());
140+
}
141+
142+
[Theory]
143+
[InlineData(-4567.0f)]
144+
[InlineData(-4567.89101f)]
145+
[InlineData(0.0f)]
146+
[InlineData(4567.0f)]
147+
[InlineData(4567.89101f)]
148+
public static void op_UnaryPlus(float value)
149+
{
150+
NFloat result = +(new NFloat(value));
151+
Assert.Equal(+value, result.Value);
152+
}
153+
154+
[Theory]
155+
[InlineData(-4567.0f)]
156+
[InlineData(-4567.89101f)]
157+
[InlineData(0.0f)]
158+
[InlineData(4567.0f)]
159+
[InlineData(4567.89101f)]
160+
public static void op_UnaryNegation(float value)
161+
{
162+
NFloat result = -(new NFloat(value));
163+
Assert.Equal(-value, result.Value);
164+
}
165+
166+
[Theory]
167+
[InlineData(-4567.0f)]
168+
[InlineData(-4567.89101f)]
169+
[InlineData(0.0f)]
170+
[InlineData(4567.0f)]
171+
[InlineData(4567.89101f)]
172+
public static void op_Decrement(float value)
173+
{
174+
NFloat result = new NFloat(value);
175+
--result;
176+
177+
if (Environment.Is64BitProcess)
178+
{
179+
Assert.Equal((double)value - 1, result.Value);
180+
}
181+
else
182+
{
183+
Assert.Equal(value - 1, result.Value);
184+
}
185+
}
186+
187+
[Theory]
188+
[InlineData(-4567.0f)]
189+
[InlineData(-4567.89101f)]
190+
[InlineData(0.0f)]
191+
[InlineData(4567.0f)]
192+
[InlineData(4567.89101f)]
193+
public static void op_Increment(float value)
194+
{
195+
NFloat result = new NFloat(value);
196+
++result;
197+
198+
if (Environment.Is64BitProcess)
199+
{
200+
Assert.Equal((double)value + 1, result.Value);
201+
}
202+
else
203+
{
204+
Assert.Equal(value + 1, result.Value);
205+
}
206+
}
207+
208+
[Theory]
209+
[InlineData(-4567.0f, 3.14f)]
210+
[InlineData(-4567.89101f, 3.14569f)]
211+
[InlineData(0.0f, 3.14f)]
212+
[InlineData(4567.0f, -3.14f)]
213+
[InlineData(4567.89101f, -3.14569f)]
214+
public static void op_Addition(float left, float right)
215+
{
216+
NFloat result = new NFloat(left) + new NFloat(right);
217+
218+
if (Environment.Is64BitProcess)
219+
{
220+
Assert.Equal((double)left + right, result.Value);
221+
}
222+
else
223+
{
224+
Assert.Equal(left + right, result.Value);
225+
}
226+
}
227+
228+
[Theory]
229+
[InlineData(-4567.0f, 3.14f)]
230+
[InlineData(-4567.89101f, 3.14569f)]
231+
[InlineData(0.0f, 3.14f)]
232+
[InlineData(4567.0f, -3.14f)]
233+
[InlineData(4567.89101f, -3.14569f)]
234+
public static void op_Subtraction(float left, float right)
235+
{
236+
NFloat result = new NFloat(left) - new NFloat(right);
237+
238+
if (Environment.Is64BitProcess)
239+
{
240+
Assert.Equal((double)left - right, result.Value);
241+
}
242+
else
243+
{
244+
Assert.Equal(left - right, result.Value);
245+
}
246+
}
247+
248+
[Theory]
249+
[InlineData(-4567.0f, 3.14f)]
250+
[InlineData(-4567.89101f, 3.14569f)]
251+
[InlineData(0.0f, 3.14f)]
252+
[InlineData(4567.0f, -3.14f)]
253+
[InlineData(4567.89101f, -3.14569f)]
254+
public static void op_Multiply(float left, float right)
255+
{
256+
NFloat result = new NFloat(left) * new NFloat(right);
257+
258+
if (Environment.Is64BitProcess)
259+
{
260+
Assert.Equal((double)left * right, result.Value);
261+
}
262+
else
263+
{
264+
Assert.Equal(left * right, result.Value);
265+
}
266+
}
267+
268+
[Theory]
269+
[InlineData(-4567.0f, 3.14f)]
270+
[InlineData(-4567.89101f, 3.14569f)]
271+
[InlineData(0.0f, 3.14f)]
272+
[InlineData(4567.0f, -3.14f)]
273+
[InlineData(4567.89101f, -3.14569f)]
274+
public static void op_Division(float left, float right)
275+
{
276+
NFloat result = new NFloat(left) / new NFloat(right);
277+
278+
if (Environment.Is64BitProcess)
279+
{
280+
Assert.Equal((double)left / right, result.Value);
281+
}
282+
else
283+
{
284+
Assert.Equal(left / right, result.Value);
285+
}
286+
}
287+
288+
[Theory]
289+
[InlineData(-4567.0f, 3.14f)]
290+
[InlineData(-4567.89101f, 3.14569f)]
291+
[InlineData(0.0f, 3.14f)]
292+
[InlineData(4567.0f, -3.14f)]
293+
[InlineData(4567.89101f, -3.14569f)]
294+
public static void op_Modulus(float left, float right)
295+
{
296+
NFloat result = new NFloat(left) % new NFloat(right);
297+
298+
if (Environment.Is64BitProcess)
299+
{
300+
Assert.Equal((double)left % right, result.Value);
301+
}
302+
else
303+
{
304+
Assert.Equal(left % right, result.Value);
305+
}
306+
}
307+
308+
[Theory]
309+
[InlineData(789.0f, 789.0f)]
310+
[InlineData(789.0f, -789.0f)]
311+
[InlineData(789.0f, 0.0f)]
312+
[InlineData(789.0f, 1000.0f)]
313+
public void op_Equality(float left, float right)
314+
{
315+
bool result = new NFloat(left) == new NFloat(right);
316+
Assert.Equal(left == right, result);
317+
}
318+
319+
[Theory]
320+
[InlineData(789.0f, 789.0f)]
321+
[InlineData(789.0f, -789.0f)]
322+
[InlineData(789.0f, 0.0f)]
323+
[InlineData(789.0f, 1000.0f)]
324+
public void op_Inequality(float left, float right)
325+
{
326+
bool result = new NFloat(left) != new NFloat(right);
327+
Assert.Equal(left != right, result);
328+
}
329+
330+
[Theory]
331+
[InlineData(789.0f, 789.0f)]
332+
[InlineData(789.0f, -789.0f)]
333+
[InlineData(789.0f, 0.0f)]
334+
[InlineData(789.0f, 1000.0f)]
335+
public void op_GreaterThan(float left, float right)
336+
{
337+
bool result = new NFloat(left) > new NFloat(right);
338+
Assert.Equal(left > right, result);
339+
}
340+
341+
[Theory]
342+
[InlineData(789.0f, 789.0f)]
343+
[InlineData(789.0f, -789.0f)]
344+
[InlineData(789.0f, 0.0f)]
345+
[InlineData(789.0f, 1000.0f)]
346+
public void op_GreaterThanOrEqual(float left, float right)
347+
{
348+
bool result = new NFloat(left) >= new NFloat(right);
349+
Assert.Equal(left >= right, result);
350+
}
351+
352+
[Theory]
353+
[InlineData(789.0f, 789.0f)]
354+
[InlineData(789.0f, -789.0f)]
355+
[InlineData(789.0f, 0.0f)]
356+
[InlineData(789.0f, 1000.0f)]
357+
public void op_LessThan(float left, float right)
358+
{
359+
bool result = new NFloat(left) < new NFloat(right);
360+
Assert.Equal(left < right, result);
361+
}
362+
363+
[Theory]
364+
[InlineData(789.0f, 789.0f)]
365+
[InlineData(789.0f, -789.0f)]
366+
[InlineData(789.0f, 0.0f)]
367+
[InlineData(789.0f, 1000.0f)]
368+
public void op_LessThanOrEqual(float left, float right)
369+
{
370+
bool result = new NFloat(left) <= new NFloat(right);
371+
Assert.Equal(left <= right, result);
372+
}
373+
374+
[Theory]
375+
[InlineData(-4567.0f)]
376+
[InlineData(-4567.89101f)]
377+
[InlineData(0.0f)]
378+
[InlineData(4567.0f)]
379+
[InlineData(4567.89101f)]
380+
public void DoubleToNFloat(float value)
381+
{
382+
NFloat result = (NFloat)(double)value;
383+
384+
if (Environment.Is64BitProcess)
385+
{
386+
Assert.Equal(value, result.Value);
387+
}
388+
else
389+
{
390+
Assert.Equal((float)value, result.Value);
391+
}
392+
}
393+
394+
[Theory]
395+
[InlineData(-4567.0f)]
396+
[InlineData(-4567.89101f)]
397+
[InlineData(0.0f)]
398+
[InlineData(4567.0f)]
399+
[InlineData(4567.89101f)]
400+
public void NFloatToByte(float value)
401+
{
402+
byte result = (byte)new NFloat(value);
403+
Assert.Equal((byte)value, result);
404+
}
405+
406+
[Theory]
407+
[InlineData(-4567.0f)]
408+
[InlineData(-4567.89101f)]
409+
[InlineData(0.0f)]
410+
[InlineData(4567.0f)]
411+
[InlineData(4567.89101f)]
412+
public void NFloatToChar(float value)
413+
{
414+
char result = (char)new NFloat(value);
415+
Assert.Equal((char)value, result);
416+
}
417+
418+
[Theory]
419+
[InlineData(-4567.0f)]
420+
[InlineData(-4567.89101f)]
421+
[InlineData(0.0f)]
422+
[InlineData(4567.0f)]
423+
[InlineData(4567.89101f)]
424+
public void NFloatToDecimal(float value)
425+
{
426+
decimal result = (decimal)new NFloat(value);
427+
428+
if (Environment.Is64BitProcess)
429+
{
430+
Assert.Equal((decimal)(double)value, result);
431+
}
432+
else
433+
{
434+
Assert.Equal((decimal)value, result);
435+
}
436+
}
437+
438+
[Theory]
439+
[InlineData(-4567.0f)]
440+
[InlineData(-4567.89101f)]
441+
[InlineData(0.0f)]
442+
[InlineData(4567.0f)]
443+
[InlineData(4567.89101f)]
444+
public void NFloatToInt16(float value)
445+
{
446+
short result = (short)new NFloat(value);
447+
Assert.Equal((short)value, result);
448+
}
449+
450+
[Theory]
451+
[InlineData(-4567.0f)]
452+
[InlineData(-4567.89101f)]
453+
[InlineData(0.0f)]
454+
[InlineData(4567.0f)]
455+
[InlineData(4567.89101f)]
456+
public void NFloatToInt32(float value)
457+
{
458+
int result = (int)new NFloat(value);
459+
Assert.Equal((int)value, result);
460+
}
461+
462+
[Theory]
463+
[InlineData(-4567.0f)]
464+
[InlineData(-4567.89101f)]
465+
[InlineData(0.0f)]
466+
[InlineData(4567.0f)]
467+
[InlineData(4567.89101f)]
468+
public void NFloatToInt64(float value)
469+
{
470+
long result = (long)new NFloat(value);
471+
Assert.Equal((long)value, result);
472+
}
473+
474+
[Theory]
475+
[InlineData(-4567.0f)]
476+
[InlineData(-4567.89101f)]
477+
[InlineData(0.0f)]
478+
[InlineData(4567.0f)]
479+
[InlineData(4567.89101f)]
480+
public void NFloatToIntPtr(float value)
481+
{
482+
nint result = (nint)new NFloat(value);
483+
Assert.Equal((nint)value, result);
484+
}
485+
486+
[Theory]
487+
[InlineData(-4567.0f)]
488+
[InlineData(-4567.89101f)]
489+
[InlineData(0.0f)]
490+
[InlineData(4567.0f)]
491+
[InlineData(4567.89101f)]
492+
public void NFloatToSByte(float value)
493+
{
494+
sbyte result = (sbyte)new NFloat(value);
495+
Assert.Equal((sbyte)value, result);
496+
}
497+
498+
[Theory]
499+
[InlineData(-4567.0f)]
500+
[InlineData(-4567.89101f)]
501+
[InlineData(0.0f)]
502+
[InlineData(4567.0f)]
503+
[InlineData(4567.89101f)]
504+
public void NFloatToSingle(float value)
505+
{
506+
float result = (float)new NFloat(value);
507+
Assert.Equal(value, result);
508+
}
509+
510+
[Theory]
511+
[InlineData(-4567.0f)]
512+
[InlineData(-4567.89101f)]
513+
[InlineData(0.0f)]
514+
[InlineData(4567.0f)]
515+
[InlineData(4567.89101f)]
516+
public void NFloatToUInt16(float value)
517+
{
518+
ushort result = (ushort)new NFloat(value);
519+
Assert.Equal((ushort)value, result);
520+
}
521+
522+
[Theory]
523+
[InlineData(-4567.0f)]
524+
[InlineData(-4567.89101f)]
525+
[InlineData(0.0f)]
526+
[InlineData(4567.0f)]
527+
[InlineData(4567.89101f)]
528+
public void NFloatToUInt32(float value)
529+
{
530+
uint result = (uint)new NFloat(value);
531+
Assert.Equal((uint)value, result);
532+
}
533+
534+
[Theory]
535+
[InlineData(-4567.0f)]
536+
[InlineData(-4567.89101f)]
537+
[InlineData(0.0f)]
538+
[InlineData(4567.0f)]
539+
[InlineData(4567.89101f)]
540+
public void NFloatToUInt64(float value)
541+
{
542+
ulong result = (ulong)new NFloat(value);
543+
Assert.Equal((ulong)value, result);
544+
}
545+
546+
[Theory]
547+
[InlineData(-4567.0f)]
548+
[InlineData(-4567.89101f)]
549+
[InlineData(0.0f)]
550+
[InlineData(4567.0f)]
551+
[InlineData(4567.89101f)]
552+
public void NFloatToUIntPtr(float value)
553+
{
554+
nuint result = (nuint)new NFloat(value);
555+
Assert.Equal((nuint)value, result);
556+
}
557+
558+
[Theory]
559+
[InlineData((byte)0)]
560+
[InlineData((byte)5)]
561+
[InlineData((byte)42)]
562+
[InlineData((byte)127)]
563+
[InlineData((byte)255)]
564+
public void ByteToNFloat(byte value)
565+
{
566+
NFloat result = value;
567+
Assert.Equal(value, result.Value);
568+
}
569+
570+
[Theory]
571+
[InlineData('A')]
572+
[InlineData('B')]
573+
[InlineData('C')]
574+
[InlineData('D')]
575+
[InlineData('E')]
576+
public void CharToNFloat(char value)
577+
{
578+
NFloat result = value;
579+
Assert.Equal(value, result.Value);
580+
}
581+
582+
[Theory]
583+
[InlineData((short)-255)]
584+
[InlineData((short)-127)]
585+
[InlineData((short)0)]
586+
[InlineData((short)127)]
587+
[InlineData((short)255)]
588+
public void Int16ToNFloat(short value)
589+
{
590+
NFloat result = value;
591+
Assert.Equal(value, result.Value);
592+
}
593+
594+
[Theory]
595+
[InlineData(-255)]
596+
[InlineData(-127)]
597+
[InlineData(0)]
598+
[InlineData(127)]
599+
[InlineData(255)]
600+
public void Int32ToNFloat(int value)
601+
{
602+
NFloat result = value;
603+
Assert.Equal(value, result.Value);
604+
}
605+
606+
[Theory]
607+
[InlineData((long)-255)]
608+
[InlineData((long)-127)]
609+
[InlineData((long)0)]
610+
[InlineData((long)127)]
611+
[InlineData((long)255)]
612+
public void Int64ToNFloat(long value)
613+
{
614+
NFloat result = value;
615+
Assert.Equal(value, result.Value);
616+
}
617+
618+
[Theory]
619+
[InlineData((int)-255)]
620+
[InlineData((int)-127)]
621+
[InlineData((int)0)]
622+
[InlineData((int)127)]
623+
[InlineData((int)255)]
624+
public void IntPtrToNFloat(int value)
625+
{
626+
NFloat result = (nint)value;
627+
Assert.Equal(value, result.Value);
628+
}
629+
630+
[Theory]
631+
[InlineData((sbyte)-127)]
632+
[InlineData((sbyte)-63)]
633+
[InlineData((sbyte)0)]
634+
[InlineData((sbyte)63)]
635+
[InlineData((sbyte)127)]
636+
public void SByteToNFloat(sbyte value)
637+
{
638+
NFloat result = value;
639+
Assert.Equal(value, result.Value);
640+
}
641+
642+
[Theory]
643+
[InlineData(-4567.0f)]
644+
[InlineData(-4567.89101f)]
645+
[InlineData(0.0f)]
646+
[InlineData(4567.0f)]
647+
[InlineData(4567.89101f)]
648+
public void SingleToNFloat(float value)
649+
{
650+
NFloat result = value;
651+
Assert.Equal(value, result.Value);
652+
}
653+
654+
[Theory]
655+
[InlineData((ushort)0)]
656+
[InlineData((ushort)5)]
657+
[InlineData((ushort)42)]
658+
[InlineData((ushort)127)]
659+
[InlineData((ushort)255)]
660+
public void UInt16ToNFloat(ushort value)
661+
{
662+
NFloat result = value;
663+
Assert.Equal(value, result.Value);
664+
}
665+
666+
[Theory]
667+
[InlineData((uint)0)]
668+
[InlineData((uint)5)]
669+
[InlineData((uint)42)]
670+
[InlineData((uint)127)]
671+
[InlineData((uint)255)]
672+
public void UInt32ToNFloat(uint value)
673+
{
674+
NFloat result = value;
675+
Assert.Equal(value, result.Value);
676+
}
677+
678+
[Theory]
679+
[InlineData((ulong)0)]
680+
[InlineData((ulong)5)]
681+
[InlineData((ulong)42)]
682+
[InlineData((ulong)127)]
683+
[InlineData((ulong)255)]
684+
public void UInt64ToNFloat(ulong value)
685+
{
686+
NFloat result = value;
687+
Assert.Equal(value, result.Value);
688+
}
689+
690+
[Theory]
691+
[InlineData((uint)0)]
692+
[InlineData((uint)5)]
693+
[InlineData((uint)42)]
694+
[InlineData((uint)127)]
695+
[InlineData((uint)255)]
696+
public void UIntPtrToNFloat(uint value)
697+
{
698+
NFloat result = (nuint)value;
699+
Assert.Equal(value, result.Value);
700+
}
701+
702+
[Theory]
703+
[InlineData(-4567.0f)]
704+
[InlineData(-4567.89101f)]
705+
[InlineData(0.0f)]
706+
[InlineData(4567.0f)]
707+
[InlineData(4567.89101f)]
708+
public void NFloatToDouble(float value)
709+
{
710+
double result = new NFloat(value);
711+
Assert.Equal(value, result);
48712
}
49713

50714
public static IEnumerable<object[]> EqualsData()
@@ -83,7 +747,6 @@ public void NaNEqualsTest()
83747
[InlineData(0.0f)]
84748
[InlineData(4567.0f)]
85749
[InlineData(4567.89101f)]
86-
87750
[InlineData(float.NaN)]
88751
public static void ToStringTest64(float value)
89752
{
@@ -106,15 +769,5 @@ public static void ToStringTest32(float value)
106769

107770
Assert.Equal(value.ToString(), nfloat.ToString());
108771
}
109-
110-
[Fact]
111-
public unsafe void Size()
112-
{
113-
int size = PlatformDetection.Is32BitProcess ? 4 : 8;
114-
#pragma warning disable xUnit2000 // The value under test here is the sizeof expression
115-
Assert.Equal(size, sizeof(NFloat));
116-
#pragma warning restore xUnit2000
117-
Assert.Equal(size, Marshal.SizeOf<NFloat>());
118-
}
119772
}
120773
}

0 commit comments

Comments
 (0)
Please sign in to comment.