core/org.eclipse.statet.rj.data-tests/src/org/eclipse/statet/rj/data/RDataUtilsTest.java

/*=============================================================================#
 # Copyright (c) 2020 Stephan Wahlbrink and others.
 # 
 # This program and the accompanying materials are made available under the
 # terms of the Eclipse Public License 2.0 which is available at
 # https://www.eclipse.org/legal/epl-2.0, or the Apache License, Version 2.0
 # which is available at https://www.apache.org/licenses/LICENSE-2.0.
 # 
 # SPDX-License-Identifier: EPL-2.0 OR Apache-2.0
 # 
 # Contributors:
 #     Stephan Wahlbrink <sw@wahlbrink.eu> - initial API and implementation
 #=============================================================================*/

package org.eclipse.statet.rj.data;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.jupiter.api.Assertions.fail;

import org.junit.jupiter.api.Test;

import org.eclipse.statet.jcommons.lang.NonNullByDefault;
import org.eclipse.statet.jcommons.lang.Nullable;

import org.eclipse.statet.rj.data.impl.DefaultRObjectFactory;
import org.eclipse.statet.rj.data.impl.RCharacter32Store;
import org.eclipse.statet.rj.data.impl.RInteger32Store;
import org.eclipse.statet.rj.data.impl.RLogicalByte32Store;
import org.eclipse.statet.rj.data.impl.RNullImpl;
import org.eclipse.statet.rj.data.impl.RNumericB32Store;


@NonNullByDefault
public class RDataUtilsTest {
	
	
	private static final DefaultRObjectFactory FACTORY= DefaultRObjectFactory.INSTANCE;
	
	
	public RDataUtilsTest() {
	}
	
	
	@Test
	public void isSingleLogi() {
		assertTrue(RDataUtils.isSingleLogi(FACTORY.createLogiVector(1)));
		assertTrue(RDataUtils.isSingleLogi(FACTORY.createLogiVector(new boolean[] { true })));
		
		assertTrue(RDataUtils.isSingleLogi(FACTORY.createVector(
				new RLogicalByte32Store(new boolean[1], new boolean[] { true }) )));
		
		assertFalse(RDataUtils.isSingleLogi(null));
		assertFalse(RDataUtils.isSingleLogi(RNullImpl.INSTANCE));
		assertFalse(RDataUtils.isSingleLogi(FACTORY.createCharVector(1)));
		assertFalse(RDataUtils.isSingleLogi(FACTORY.createLogiVector(0)));
		assertFalse(RDataUtils.isSingleLogi(FACTORY.createLogiVector(2)));
	}
	
	@Test
	public void checkSingleLogi() {
		try {
			assertEquals(Boolean.FALSE,
					RDataUtils.checkSingleLogi(FACTORY.createLogiVector(1)));
			assertEquals(Boolean.TRUE,
					RDataUtils.checkSingleLogi(FACTORY.createLogiVector(new boolean[] { true })));
			
			assertNull(
					RDataUtils.checkSingleLogi(FACTORY.createVector(
							new RLogicalByte32Store(new boolean[1], new boolean[] { true }) )));
		}
		catch (final UnexpectedRDataException e) {
			fail(e);
		}
		
		assertThrows(UnexpectedRDataException.class, () ->
				RDataUtils.checkSingleLogi(null));
		assertThrows(UnexpectedRDataException.class, () ->
				RDataUtils.checkSingleLogi(RNullImpl.INSTANCE));
		assertThrows(UnexpectedRDataException.class, () ->
				RDataUtils.checkSingleLogi(FACTORY.createCharVector(1)));
		assertThrows(UnexpectedRDataException.class, () ->
				RDataUtils.checkSingleLogi(FACTORY.createLogiVector(0)));
		assertThrows(UnexpectedRDataException.class, () ->
				RDataUtils.checkSingleLogi(FACTORY.createLogiVector(2)));
	}
	
	@Test
	@SuppressWarnings("boxing")
	public void checkSingleLogiValue() {
		try {
			assertEquals(false,
					RDataUtils.checkSingleLogiValue(FACTORY.createLogiVector(1)));
			assertEquals(true,
					RDataUtils.checkSingleLogiValue(FACTORY.createLogiVector(new boolean[] { true })));
		}
		catch (final UnexpectedRDataException e) {
			fail(e);
		}
		
		assertThrows(UnexpectedRDataException.class, () ->
				RDataUtils.checkSingleLogiValue(FACTORY.createVector(
						new RLogicalByte32Store(new boolean[1], new boolean[] { true }) )));
		
		assertThrows(UnexpectedRDataException.class, () ->
				RDataUtils.checkSingleLogiValue(null));
		assertThrows(UnexpectedRDataException.class, () ->
				RDataUtils.checkSingleLogiValue(RNullImpl.INSTANCE));
		assertThrows(UnexpectedRDataException.class, () ->
				RDataUtils.checkSingleLogiValue(FACTORY.createCharVector(1)));
		assertThrows(UnexpectedRDataException.class, () ->
				RDataUtils.checkSingleLogiValue(FACTORY.createLogiVector(0)));
		assertThrows(UnexpectedRDataException.class, () ->
				RDataUtils.checkSingleLogiValue(FACTORY.createLogiVector(2)));
	}
	
	@Test
	public void isSingleInt() {
		assertTrue(RDataUtils.isSingleInt(FACTORY.createIntVector(1)));
		assertTrue(RDataUtils.isSingleInt(FACTORY.createIntVector(new int[] { 1 })));
		
		assertTrue(RDataUtils.isSingleInt(FACTORY.createVector(
				new RInteger32Store(new int[1], new boolean[] { true }) )));
		
		assertFalse(RDataUtils.isSingleInt(null));
		assertFalse(RDataUtils.isSingleInt(RNullImpl.INSTANCE));
		assertFalse(RDataUtils.isSingleInt(FACTORY.createLogiVector(1)));
		assertFalse(RDataUtils.isSingleInt(FACTORY.createIntVector(0)));
		assertFalse(RDataUtils.isSingleInt(FACTORY.createIntVector(2)));
	}
	
	@Test
	public void checkSingleInt() {
		try {
			assertEquals(Integer.valueOf(0),
					RDataUtils.checkSingleInt(FACTORY.createIntVector(1)));
			assertEquals(Integer.valueOf(1),
					RDataUtils.checkSingleInt(FACTORY.createIntVector(new int[] { 1 })));
			
			assertNull(
					RDataUtils.checkSingleInt(FACTORY.createVector(
							new RInteger32Store(new int[1], new boolean[] { true }) )));
		}
		catch (final UnexpectedRDataException e) {
			fail(e);
		}
		
		assertThrows(UnexpectedRDataException.class, () ->
				RDataUtils.checkSingleInt(null));
		assertThrows(UnexpectedRDataException.class, () ->
				RDataUtils.checkSingleInt(RNullImpl.INSTANCE));
		assertThrows(UnexpectedRDataException.class, () ->
				RDataUtils.checkSingleInt(FACTORY.createLogiVector(1)));
		assertThrows(UnexpectedRDataException.class, () ->
				RDataUtils.checkSingleInt(FACTORY.createIntVector(0)));
		assertThrows(UnexpectedRDataException.class, () ->
				RDataUtils.checkSingleInt(FACTORY.createIntVector(2)));
	}
	
	@Test
	public void checkSingleIntValue() {
		try {
			assertEquals(0,
					RDataUtils.checkSingleIntValue(FACTORY.createIntVector(1)));
			assertEquals(1,
					RDataUtils.checkSingleIntValue(FACTORY.createIntVector(new int[] { 1 })));
		}
		catch (final UnexpectedRDataException e) {
			fail(e);
		}
		
		assertThrows(UnexpectedRDataException.class, () ->
				RDataUtils.checkSingleIntValue(FACTORY.createVector(
						new RInteger32Store(new int[1], new boolean[] { true }) )));
		
		assertThrows(UnexpectedRDataException.class, () ->
				RDataUtils.checkSingleIntValue(null));
		assertThrows(UnexpectedRDataException.class, () ->
				RDataUtils.checkSingleIntValue(RNullImpl.INSTANCE));
		assertThrows(UnexpectedRDataException.class, () ->
				RDataUtils.checkSingleIntValue(FACTORY.createLogiVector(1)));
		assertThrows(UnexpectedRDataException.class, () ->
				RDataUtils.checkSingleIntValue(FACTORY.createIntVector(0)));
		assertThrows(UnexpectedRDataException.class, () ->
				RDataUtils.checkSingleIntValue(FACTORY.createIntVector(2)));
	}
	
	@Test
	public void isSingleNum() {
		assertTrue(RDataUtils.isSingleNum(FACTORY.createNumVector(1)));
		assertTrue(RDataUtils.isSingleNum(FACTORY.createNumVector(new double[] { 1.0 })));
		
		assertTrue(RDataUtils.isSingleNum(FACTORY.createVector(
				new RNumericB32Store(new double[1], new boolean[] { true }) )));
		
		assertFalse(RDataUtils.isSingleNum(null));
		assertFalse(RDataUtils.isSingleNum(RNullImpl.INSTANCE));
		assertFalse(RDataUtils.isSingleNum(FACTORY.createLogiVector(1)));
		assertFalse(RDataUtils.isSingleNum(FACTORY.createNumVector(0)));
		assertFalse(RDataUtils.isSingleNum(FACTORY.createNumVector(2)));
	}
	
	@Test
	public void checkSingleNum() {
		try {
			assertEquals(Double.valueOf(0.0),
					RDataUtils.checkSingleNum(FACTORY.createNumVector(1)));
			assertEquals(Double.valueOf(1.0),
					RDataUtils.checkSingleNum(FACTORY.createNumVector(new double[] { 1.0 })));
			
			assertNull(
					RDataUtils.checkSingleNum(FACTORY.createVector(
							new RNumericB32Store(new double[1], new boolean[] { true }) )));
		}
		catch (final UnexpectedRDataException e) {
			fail(e);
		}
		
		assertThrows(UnexpectedRDataException.class, () ->
				RDataUtils.checkSingleNum(null));
		assertThrows(UnexpectedRDataException.class, () ->
				RDataUtils.checkSingleNum(RNullImpl.INSTANCE));
		assertThrows(UnexpectedRDataException.class, () ->
				RDataUtils.checkSingleNum(FACTORY.createLogiVector(1)));
		assertThrows(UnexpectedRDataException.class, () ->
				RDataUtils.checkSingleNum(FACTORY.createNumVector(0)));
		assertThrows(UnexpectedRDataException.class, () ->
				RDataUtils.checkSingleNum(FACTORY.createNumVector(2)));
	}
	
	@Test
	public void checkSingleNumValue() {
		try {
			assertEquals(0.0,
					RDataUtils.checkSingleNumValue(FACTORY.createNumVector(1)));
			assertEquals(1.0,
					RDataUtils.checkSingleNumValue(FACTORY.createNumVector(new double[] { 1.0 })));
		}
		catch (final UnexpectedRDataException e) {
			fail(e);
		}
		
		assertThrows(UnexpectedRDataException.class, () ->
				RDataUtils.checkSingleNumValue(FACTORY.createVector(
						new RNumericB32Store(new double[1], new boolean[] { true }) )));
		
		assertThrows(UnexpectedRDataException.class, () ->
				RDataUtils.checkSingleNumValue(null));
		assertThrows(UnexpectedRDataException.class, () ->
				RDataUtils.checkSingleNumValue(RNullImpl.INSTANCE));
		assertThrows(UnexpectedRDataException.class, () ->
				RDataUtils.checkSingleNumValue(FACTORY.createLogiVector(1)));
		assertThrows(UnexpectedRDataException.class, () ->
				RDataUtils.checkSingleNumValue(FACTORY.createNumVector(0)));
		assertThrows(UnexpectedRDataException.class, () ->
				RDataUtils.checkSingleNumValue(FACTORY.createNumVector(2)));
	}
	
	@Test
	public void isSingleChar() {
		assertTrue(RDataUtils.isSingleChar(FACTORY.createCharVector(1)));
		assertTrue(RDataUtils.isSingleChar(FACTORY.createCharVector(new @Nullable String[] { "test" })));
		
		assertTrue(RDataUtils.isSingleChar(FACTORY.createVector(
				new RCharacter32Store(new @Nullable String[] { null }) )));
		
		assertFalse(RDataUtils.isSingleChar(null));
		assertFalse(RDataUtils.isSingleChar(RNullImpl.INSTANCE));
		assertFalse(RDataUtils.isSingleChar(FACTORY.createLogiVector(1)));
		assertFalse(RDataUtils.isSingleChar(FACTORY.createCharVector(0)));
		assertFalse(RDataUtils.isSingleChar(FACTORY.createCharVector(2)));
	}
	
	@Test
	public void checkSingleChar() {
		try {
			assertEquals("",
					RDataUtils.checkSingleChar(FACTORY.createCharVector(1)));
			assertEquals("test",
					RDataUtils.checkSingleChar(FACTORY.createCharVector(new @Nullable String[] { "test" })));
			
			assertNull(
					RDataUtils.checkSingleChar(FACTORY.createVector(
							new RCharacter32Store(new @Nullable String[] { null }) )));
		}
		catch (final UnexpectedRDataException e) {
			fail(e);
		}
		
		assertThrows(UnexpectedRDataException.class, () ->
				RDataUtils.checkSingleChar(null));
		assertThrows(UnexpectedRDataException.class, () ->
				RDataUtils.checkSingleChar(RNullImpl.INSTANCE));
		assertThrows(UnexpectedRDataException.class, () ->
				RDataUtils.checkSingleChar(FACTORY.createLogiVector(1)));
		assertThrows(UnexpectedRDataException.class, () ->
				RDataUtils.checkSingleChar(FACTORY.createCharVector(0)));
		assertThrows(UnexpectedRDataException.class, () ->
				RDataUtils.checkSingleChar(FACTORY.createCharVector(2)));
	}
	
	@Test
	public void checkSingleCharValue() {
		try {
			assertEquals("",
					RDataUtils.checkSingleCharValue(FACTORY.createCharVector(1)));
			assertEquals("test",
					RDataUtils.checkSingleCharValue(FACTORY.createCharVector(new @Nullable String[] { "test" })));
		}
		catch (final UnexpectedRDataException e) {
			fail(e);
		}
		
		assertThrows(UnexpectedRDataException.class, () ->
				RDataUtils.checkSingleCharValue(FACTORY.createVector(
						new RCharacter32Store(new @Nullable String[] { null }) )));
		
		assertThrows(UnexpectedRDataException.class, () ->
				RDataUtils.checkSingleCharValue(null));
		assertThrows(UnexpectedRDataException.class, () ->
				RDataUtils.checkSingleCharValue(RNullImpl.INSTANCE));
		assertThrows(UnexpectedRDataException.class, () ->
				RDataUtils.checkSingleCharValue(FACTORY.createLogiVector(1)));
		assertThrows(UnexpectedRDataException.class, () ->
				RDataUtils.checkSingleCharValue(FACTORY.createCharVector(0)));
		assertThrows(UnexpectedRDataException.class, () ->
				RDataUtils.checkSingleCharValue(FACTORY.createCharVector(2)));
	}
	
}