001/*
002 * Licensed to the Apache Software Foundation (ASF) under one
003 * or more contributor license agreements.  See the NOTICE file
004 * distributed with this work for additional information
005 * regarding copyright ownership.  The ASF licenses this file
006 * to you under the Apache License, Version 2.0 (the
007 * "License"); you may not use this file except in compliance
008 * with the License.  You may obtain a copy of the License at
009 *
010 *     http://www.apache.org/licenses/LICENSE-2.0
011 *
012 * Unless required by applicable law or agreed to in writing, software
013 * distributed under the License is distributed on an "AS IS" BASIS,
014 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
015 * See the License for the specific language governing permissions and
016 * limitations under the License.
017 */
018package org.apache.hadoop.hbase.hbtop.field;
019
020import static org.hamcrest.CoreMatchers.is;
021import static org.hamcrest.MatcherAssert.assertThat;
022import static org.junit.jupiter.api.Assertions.fail;
023
024import org.apache.hadoop.hbase.Size;
025import org.apache.hadoop.hbase.testclassification.SmallTests;
026import org.junit.jupiter.api.Tag;
027import org.junit.jupiter.api.Test;
028
029@Tag(SmallTests.TAG)
030public class TestFieldValue {
031
032  @Test
033  public void testParseAndAsSomethingMethod() {
034    // String
035    FieldValue stringFieldValue = new FieldValue("aaa", FieldValueType.STRING);
036    assertThat(stringFieldValue.asString(), is("aaa"));
037
038    try {
039      new FieldValue(1, FieldValueType.STRING);
040      fail();
041    } catch (IllegalArgumentException ignored) {
042    }
043
044    // Integer
045    FieldValue integerFieldValue = new FieldValue(100, FieldValueType.INTEGER);
046    assertThat(integerFieldValue.asInt(), is(100));
047
048    integerFieldValue = new FieldValue("100", FieldValueType.INTEGER);
049    assertThat(integerFieldValue.asInt(), is(100));
050
051    try {
052      new FieldValue("aaa", FieldValueType.INTEGER);
053      fail();
054    } catch (IllegalArgumentException ignored) {
055    }
056
057    // Long
058    FieldValue longFieldValue = new FieldValue(100L, FieldValueType.LONG);
059    assertThat(longFieldValue.asLong(), is(100L));
060
061    longFieldValue = new FieldValue("100", FieldValueType.LONG);
062    assertThat(longFieldValue.asLong(), is(100L));
063
064    try {
065      new FieldValue("aaa", FieldValueType.LONG);
066      fail();
067    } catch (IllegalArgumentException ignored) {
068    }
069
070    try {
071      new FieldValue(100, FieldValueType.LONG);
072      fail();
073    } catch (IllegalArgumentException ignored) {
074    }
075
076    // Float
077    FieldValue floatFieldValue = new FieldValue(1.0f, FieldValueType.FLOAT);
078    assertThat(floatFieldValue.asFloat(), is(1.0f));
079
080    floatFieldValue = new FieldValue("1", FieldValueType.FLOAT);
081    assertThat(floatFieldValue.asFloat(), is(1.0f));
082
083    try {
084      new FieldValue("aaa", FieldValueType.FLOAT);
085      fail();
086    } catch (IllegalArgumentException ignored) {
087    }
088
089    try {
090      new FieldValue(1, FieldValueType.FLOAT);
091      fail();
092    } catch (IllegalArgumentException ignored) {
093    }
094
095    // Size
096    FieldValue sizeFieldValue =
097      new FieldValue(new Size(100, Size.Unit.MEGABYTE), FieldValueType.SIZE);
098    assertThat(sizeFieldValue.asString(), is("100.0MB"));
099    assertThat(sizeFieldValue.asSize(), is(new Size(100, Size.Unit.MEGABYTE)));
100
101    sizeFieldValue = new FieldValue("100MB", FieldValueType.SIZE);
102    assertThat(sizeFieldValue.asString(), is("100.0MB"));
103    assertThat(sizeFieldValue.asSize(), is(new Size(100, Size.Unit.MEGABYTE)));
104
105    try {
106      new FieldValue("100", FieldValueType.SIZE);
107      fail();
108    } catch (IllegalArgumentException ignored) {
109    }
110
111    try {
112      new FieldValue(100, FieldValueType.SIZE);
113      fail();
114    } catch (IllegalArgumentException ignored) {
115    }
116
117    // Percent
118    FieldValue percentFieldValue = new FieldValue(100f, FieldValueType.PERCENT);
119    assertThat(percentFieldValue.asString(), is("100.00%"));
120    assertThat(percentFieldValue.asFloat(), is(100f));
121
122    percentFieldValue = new FieldValue("100%", FieldValueType.PERCENT);
123    assertThat(percentFieldValue.asString(), is("100.00%"));
124    assertThat(percentFieldValue.asFloat(), is(100f));
125
126    percentFieldValue = new FieldValue("100", FieldValueType.PERCENT);
127    assertThat(percentFieldValue.asString(), is("100.00%"));
128    assertThat(percentFieldValue.asFloat(), is(100f));
129
130    try {
131      new FieldValue(100, FieldValueType.PERCENT);
132      fail();
133    } catch (IllegalArgumentException ignored) {
134    }
135  }
136
137  @Test
138  public void testCompareTo() {
139    // String
140    FieldValue stringAFieldValue = new FieldValue("a", FieldValueType.STRING);
141    FieldValue stringAFieldValue2 = new FieldValue("a", FieldValueType.STRING);
142    FieldValue stringBFieldValue = new FieldValue("b", FieldValueType.STRING);
143    FieldValue stringCapitalAFieldValue = new FieldValue("A", FieldValueType.STRING);
144
145    assertThat(stringAFieldValue.compareTo(stringAFieldValue2), is(0));
146    assertThat(stringBFieldValue.compareTo(stringAFieldValue), is(1));
147    assertThat(stringAFieldValue.compareTo(stringBFieldValue), is(-1));
148    assertThat(stringAFieldValue.compareTo(stringCapitalAFieldValue), is(32));
149
150    // Integer
151    FieldValue integer1FieldValue = new FieldValue(1, FieldValueType.INTEGER);
152    FieldValue integer1FieldValue2 = new FieldValue(1, FieldValueType.INTEGER);
153    FieldValue integer2FieldValue = new FieldValue(2, FieldValueType.INTEGER);
154
155    assertThat(integer1FieldValue.compareTo(integer1FieldValue2), is(0));
156    assertThat(integer2FieldValue.compareTo(integer1FieldValue), is(1));
157    assertThat(integer1FieldValue.compareTo(integer2FieldValue), is(-1));
158
159    // Long
160    FieldValue long1FieldValue = new FieldValue(1L, FieldValueType.LONG);
161    FieldValue long1FieldValue2 = new FieldValue(1L, FieldValueType.LONG);
162    FieldValue long2FieldValue = new FieldValue(2L, FieldValueType.LONG);
163
164    assertThat(long1FieldValue.compareTo(long1FieldValue2), is(0));
165    assertThat(long2FieldValue.compareTo(long1FieldValue), is(1));
166    assertThat(long1FieldValue.compareTo(long2FieldValue), is(-1));
167
168    // Float
169    FieldValue float1FieldValue = new FieldValue(1.0f, FieldValueType.FLOAT);
170    FieldValue float1FieldValue2 = new FieldValue(1.0f, FieldValueType.FLOAT);
171    FieldValue float2FieldValue = new FieldValue(2.0f, FieldValueType.FLOAT);
172
173    assertThat(float1FieldValue.compareTo(float1FieldValue2), is(0));
174    assertThat(float2FieldValue.compareTo(float1FieldValue), is(1));
175    assertThat(float1FieldValue.compareTo(float2FieldValue), is(-1));
176
177    // Size
178    FieldValue size100MBFieldValue =
179      new FieldValue(new Size(100, Size.Unit.MEGABYTE), FieldValueType.SIZE);
180    FieldValue size100MBFieldValue2 =
181      new FieldValue(new Size(100, Size.Unit.MEGABYTE), FieldValueType.SIZE);
182    FieldValue size200MBFieldValue =
183      new FieldValue(new Size(200, Size.Unit.MEGABYTE), FieldValueType.SIZE);
184
185    assertThat(size100MBFieldValue.compareTo(size100MBFieldValue2), is(0));
186    assertThat(size200MBFieldValue.compareTo(size100MBFieldValue), is(1));
187    assertThat(size100MBFieldValue.compareTo(size200MBFieldValue), is(-1));
188
189    // Percent
190    FieldValue percent50FieldValue = new FieldValue(50.0f, FieldValueType.PERCENT);
191    FieldValue percent50FieldValue2 = new FieldValue(50.0f, FieldValueType.PERCENT);
192    FieldValue percent100FieldValue = new FieldValue(100.0f, FieldValueType.PERCENT);
193
194    assertThat(percent50FieldValue.compareTo(percent50FieldValue2), is(0));
195    assertThat(percent100FieldValue.compareTo(percent50FieldValue), is(1));
196    assertThat(percent50FieldValue.compareTo(percent100FieldValue), is(-1));
197  }
198
199  @Test
200  public void testPlus() {
201    // String
202    FieldValue stringFieldValue = new FieldValue("a", FieldValueType.STRING);
203    FieldValue stringFieldValue2 = new FieldValue("b", FieldValueType.STRING);
204    assertThat(stringFieldValue.plus(stringFieldValue2).asString(), is("ab"));
205
206    // Integer
207    FieldValue integerFieldValue = new FieldValue(1, FieldValueType.INTEGER);
208    FieldValue integerFieldValue2 = new FieldValue(2, FieldValueType.INTEGER);
209    assertThat(integerFieldValue.plus(integerFieldValue2).asInt(), is(3));
210
211    // Long
212    FieldValue longFieldValue = new FieldValue(1L, FieldValueType.LONG);
213    FieldValue longFieldValue2 = new FieldValue(2L, FieldValueType.LONG);
214    assertThat(longFieldValue.plus(longFieldValue2).asLong(), is(3L));
215
216    // Float
217    FieldValue floatFieldValue = new FieldValue(1.2f, FieldValueType.FLOAT);
218    FieldValue floatFieldValue2 = new FieldValue(2.2f, FieldValueType.FLOAT);
219    assertThat(floatFieldValue.plus(floatFieldValue2).asFloat(), is(3.4f));
220
221    // Size
222    FieldValue sizeFieldValue =
223      new FieldValue(new Size(100, Size.Unit.MEGABYTE), FieldValueType.SIZE);
224    FieldValue sizeFieldValue2 =
225      new FieldValue(new Size(200, Size.Unit.MEGABYTE), FieldValueType.SIZE);
226    assertThat(sizeFieldValue.plus(sizeFieldValue2).asString(), is("300.0MB"));
227    assertThat(sizeFieldValue.plus(sizeFieldValue2).asSize(),
228      is(new Size(300, Size.Unit.MEGABYTE)));
229
230    // Percent
231    FieldValue percentFieldValue = new FieldValue(30f, FieldValueType.PERCENT);
232    FieldValue percentFieldValue2 = new FieldValue(60f, FieldValueType.PERCENT);
233    assertThat(percentFieldValue.plus(percentFieldValue2).asString(), is("90.00%"));
234    assertThat(percentFieldValue.plus(percentFieldValue2).asFloat(), is(90f));
235  }
236
237  @Test
238  public void testCompareToIgnoreCase() {
239    FieldValue stringAFieldValue = new FieldValue("a", FieldValueType.STRING);
240    FieldValue stringCapitalAFieldValue = new FieldValue("A", FieldValueType.STRING);
241    FieldValue stringCapitalBFieldValue = new FieldValue("B", FieldValueType.STRING);
242
243    assertThat(stringAFieldValue.compareToIgnoreCase(stringCapitalAFieldValue), is(0));
244    assertThat(stringCapitalBFieldValue.compareToIgnoreCase(stringAFieldValue), is(1));
245    assertThat(stringAFieldValue.compareToIgnoreCase(stringCapitalBFieldValue), is(-1));
246  }
247
248  @Test
249  public void testOptimizeSize() {
250    FieldValue sizeFieldValue = new FieldValue(new Size(1, Size.Unit.BYTE), FieldValueType.SIZE);
251    assertThat(sizeFieldValue.asString(), is("1.0B"));
252
253    sizeFieldValue = new FieldValue(new Size(1024, Size.Unit.BYTE), FieldValueType.SIZE);
254    assertThat(sizeFieldValue.asString(), is("1.0KB"));
255
256    sizeFieldValue = new FieldValue(new Size(2 * 1024, Size.Unit.BYTE), FieldValueType.SIZE);
257    assertThat(sizeFieldValue.asString(), is("2.0KB"));
258
259    sizeFieldValue = new FieldValue(new Size(2 * 1024, Size.Unit.KILOBYTE), FieldValueType.SIZE);
260    assertThat(sizeFieldValue.asString(), is("2.0MB"));
261
262    sizeFieldValue = new FieldValue(new Size(1024 * 1024, Size.Unit.KILOBYTE), FieldValueType.SIZE);
263    assertThat(sizeFieldValue.asString(), is("1.0GB"));
264
265    sizeFieldValue =
266      new FieldValue(new Size(2 * 1024 * 1024, Size.Unit.MEGABYTE), FieldValueType.SIZE);
267    assertThat(sizeFieldValue.asString(), is("2.0TB"));
268
269    sizeFieldValue = new FieldValue(new Size(2 * 1024, Size.Unit.TERABYTE), FieldValueType.SIZE);
270    assertThat(sizeFieldValue.asString(), is("2.0PB"));
271
272    sizeFieldValue = new FieldValue(new Size(1024 * 1024, Size.Unit.TERABYTE), FieldValueType.SIZE);
273    assertThat(sizeFieldValue.asString(), is("1024.0PB"));
274
275    sizeFieldValue = new FieldValue(new Size(1, Size.Unit.PETABYTE), FieldValueType.SIZE);
276    assertThat(sizeFieldValue.asString(), is("1.0PB"));
277
278    sizeFieldValue = new FieldValue(new Size(1024, Size.Unit.PETABYTE), FieldValueType.SIZE);
279    assertThat(sizeFieldValue.asString(), is("1024.0PB"));
280  }
281}