common/src/test/java/org/opendaylight/transportpce/common/fixedflex/GridUtilsTest.java

   1 /*
   2  * Copyright © 2020 Orange, Inc. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8
   9 package org.opendaylight.transportpce.common.fixedflex;
  10
  11
  12 import static org.junit.jupiter.api.Assertions.assertEquals;
  13 import static org.junit.jupiter.api.Assertions.assertThrows;
  14 import static org.junit.jupiter.api.Assertions.assertTrue;
  15
  16 import java.math.BigDecimal;
  17 import java.util.Arrays;
  18 import java.util.Map;
  19 import org.junit.jupiter.api.Test;
  20 import org.opendaylight.transportpce.common.ServiceRateConstant;
  21 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.device.renderer.rev211004.ServicePathInput;
  22 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.device.renderer.rev211004.ServicePathInputBuilder;
  23 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.optical.channel.types.rev211210.FrequencyGHz;
  24 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.optical.channel.types.rev211210.FrequencyTHz;
  25 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev181019.ModulationFormat;
  26 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev211210.available.freq.map.AvailFreqMaps;
  27 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev211210.available.freq.map.AvailFreqMapsKey;
  28 import org.opendaylight.yangtools.yang.common.Decimal64;
  29 import org.opendaylight.yangtools.yang.common.Uint32;
  30
  31 public class GridUtilsTest {
  32
  33     @Test
  34     void getWaveLengthIndexFromSpectrumAssigmentTest() {
  35         assertEquals(15, GridUtils.getWaveLengthIndexFromSpectrumAssigment(647), "Wavelength index should be 15");
  36     }
  37
  38     @Test
  39     void getFrequencyFromIndexTest() {
  40         BigDecimal[] expectedFrequencies = new BigDecimal[768];
  41         BigDecimal frequency = BigDecimal.valueOf(191.325);
  42         for (int i = 0; i < expectedFrequencies.length; i++) {
  43             expectedFrequencies[i] = frequency;
  44             frequency = frequency.add(BigDecimal.valueOf(0.00625));
  45         }
  46         assertEquals(0, expectedFrequencies[0].compareTo(GridUtils.getStartFrequencyFromIndex(0)),
  47             "Frequency should be 191.325");
  48         assertEquals(0, expectedFrequencies[284].compareTo(GridUtils.getStartFrequencyFromIndex(284)),
  49             "Frequency should be 193.1");
  50         assertEquals(0, expectedFrequencies[767].compareTo(GridUtils.getStartFrequencyFromIndex(767)),
  51             "Frequency should be 196.1188");
  52     }
  53
  54     @Test
  55     void initFreqMaps4FixedGrid2AvailableTest() {
  56         AvailFreqMapsKey key = new AvailFreqMapsKey(GridConstant.C_BAND);
  57         byte[] byteArray = new byte[GridConstant.NB_OCTECTS];
  58         Arrays.fill(byteArray, (byte) GridConstant.AVAILABLE_SLOT_VALUE);
  59         Map<AvailFreqMapsKey, AvailFreqMaps> availFreqMaps = GridUtils.initFreqMaps4FixedGrid2Available();
  60         assertEquals(1, availFreqMaps.size(), "Should contains 1 element");
  61         assertTrue(availFreqMaps.containsKey(key), "should contains cband key");
  62         assertTrue(Arrays.equals(byteArray, availFreqMaps.get(key).getFreqMap()), "Should have available freq map");
  63     }
  64
  65     @Test
  66     void getIndexFromFrequencyTest() {
  67         assertEquals(693, GridUtils.getIndexFromFrequency(Decimal64.valueOf("195.65625")), "Index should be 693");
  68         assertEquals(0, GridUtils.getIndexFromFrequency(Decimal64.valueOf("191.325")), "Index should be 0");
  69         assertEquals(767, GridUtils.getIndexFromFrequency(Decimal64.valueOf("196.11875")), "Index should be 767");
  70         assertEquals(8, GridUtils.getIndexFromFrequency(Decimal64.valueOf("191.375")), "Index should be 8");
  71         assertEquals(15, GridUtils.getIndexFromFrequency(Decimal64.valueOf("191.41875")), "Index should be 15");
  72         assertEquals(768, GridUtils.getIndexFromFrequency(Decimal64.valueOf("196.125")), "Index should be 768");
  73     }
  74
  75     @Test
  76     void getIndexFromFrequencyExceptionTest() {
  77         IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, () -> {
  78             GridUtils.getIndexFromFrequency(Decimal64.valueOf("196.13125"));
  79         });
  80         assertEquals("Frequency not in range 196.13125", exception.getMessage());
  81     }
  82
  83     @Test
  84     void getIndexFromFrequencyException2Test() {
  85         IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, () -> {
  86             GridUtils.getIndexFromFrequency(Decimal64.valueOf("191.31875"));
  87         });
  88         assertEquals("Frequency not in range 191.31875", exception.getMessage());
  89     }
  90
  91     @Test
  92     void getWidthFromRateAndModulationFormatTest() {
  93         assertEquals(
  94             new FrequencyGHz(Decimal64.valueOf(GridConstant.WIDTH_75)),
  95             GridUtils.getWidthFromRateAndModulationFormatToModel101(ServiceRateConstant.RATE_400,
  96                     ModulationFormat.DpQam16),
  97             "Width should be 75");
  98     }
  99
 100     @Test
 101     void getWidthFromRateAndModulationFormatNotFoundTest() {
 102         assertEquals(
 103             new FrequencyGHz(Decimal64.valueOf(GridConstant.WIDTH_40)),
 104             GridUtils.getWidthFromRateAndModulationFormatToModel101(ServiceRateConstant.RATE_100,
 105                     ModulationFormat.DpQam16),
 106             "As not found width should be 40");
 107     }
 108
 109     @Test
 110     void getCentralFrequencyTest() {
 111         assertEquals(
 112             new FrequencyTHz(Decimal64.valueOf(BigDecimal.valueOf(191.35).setScale(3))),
 113             GridUtils.getCentralFrequencyToModel101(BigDecimal.valueOf(191.325), BigDecimal.valueOf(191.375)),
 114             "Central frequency should be 191.350");
 115     }
 116
 117     @Test
 118     void getCentralFrequencyWithPrecisionTest() {
 119         assertEquals(
 120             new org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev181019.FrequencyTHz(
 121                     Decimal64.valueOf(BigDecimal.valueOf(191.35).setScale(4))),
 122             GridUtils.getCentralFrequencyWithPrecision(BigDecimal.valueOf(191.325), BigDecimal.valueOf(191.375), 4),
 123             "Central frequency should be 191.3500");
 124     }
 125
 126     @Test
 127     void getCentralFrequencyWithPrecisionAndRoundTest() {
 128         assertEquals(
 129             new org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev181019.FrequencyTHz(
 130                     Decimal64.valueOf("191.3499")),
 131             GridUtils.getCentralFrequencyWithPrecision(
 132                     BigDecimal.valueOf(191.3244445), BigDecimal.valueOf(191.3754457788), 4),
 133             "Central frequency should be 191.3499");
 134     }
 135
 136     @Test
 137     void initSpectrumInformationFromServicePathInputTest() {
 138         ServicePathInput input = new ServicePathInputBuilder()
 139                 .setWaveNumber(Uint32.valueOf(1))
 140                 .setCenterFreq(new org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev181019
 141                         .FrequencyTHz(Decimal64.valueOf("196.1")))
 142                 .setHigherSpectralSlotNumber(Uint32.valueOf(768))
 143                 .setLowerSpectralSlotNumber(Uint32.valueOf(761))
 144                 .setMaxFreq(new org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev181019
 145                         .FrequencyTHz(Decimal64.valueOf("196.125")))
 146                 .setMinFreq(new org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev181019
 147                         .FrequencyTHz(Decimal64.valueOf("196.075")))
 148                 .setNmcWidth(new org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev181019
 149                         .FrequencyGHz(Decimal64.valueOf(GridConstant.WIDTH_40)))
 150                 .build();
 151         SpectrumInformation spectrumInformation = GridUtils.initSpectrumInformationFromServicePathInput(input);
 152         assertEquals(BigDecimal.valueOf(40), spectrumInformation.getWidth(), "Width should be 40");
 153         assertEquals(Uint32.valueOf(1), spectrumInformation.getWaveLength(), "Wavelength should be 1");
 154         assertEquals(BigDecimal.valueOf(196.1).setScale(4), spectrumInformation.getCenterFrequency(),
 155             "Center freq should be 196.1");
 156         assertEquals(761, spectrumInformation.getLowerSpectralSlotNumber(), "Lower slot number should be 761");
 157         assertEquals(768, spectrumInformation.getHigherSpectralSlotNumber(), "Higher slot number should be 768");
 158         assertEquals(BigDecimal.valueOf(196.075).setScale(4), spectrumInformation.getMinFrequency(),
 159             "Min freq should be 196.075");
 160         assertEquals(BigDecimal.valueOf(196.125).setScale(4), spectrumInformation.getMaxFrequency(),
 161             "Max freq should be 196.125");
 162     }
 163
 164     @Test
 165     void initSpectrumInformationFromServicePathInputNoCenterFreqTest() {
 166         ServicePathInput input = new ServicePathInputBuilder()
 167                 .setWaveNumber(Uint32.valueOf(1))
 168                 .setHigherSpectralSlotNumber(Uint32.valueOf(768))
 169                 .setLowerSpectralSlotNumber(Uint32.valueOf(761))
 170                 .setMaxFreq(new org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev181019
 171                         .FrequencyTHz(Decimal64.valueOf("196.125")))
 172                 .setMinFreq(new org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev181019
 173                         .FrequencyTHz(Decimal64.valueOf("196.075")))
 174                 .setNmcWidth(new org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev181019
 175                         .FrequencyGHz(Decimal64.valueOf(GridConstant.WIDTH_40)))
 176                 .build();
 177         SpectrumInformation spectrumInformation = GridUtils.initSpectrumInformationFromServicePathInput(input);
 178         assertEquals(BigDecimal.valueOf(40), spectrumInformation.getWidth(), "Width should be 40");
 179         assertEquals(Uint32.valueOf(1), spectrumInformation.getWaveLength(), "Wavelength should be 1");
 180         assertEquals(BigDecimal.valueOf(196.1).setScale(4), spectrumInformation.getCenterFrequency(),
 181             "Center freq should be 196.1");
 182         assertEquals(761, spectrumInformation.getLowerSpectralSlotNumber(), "Lower slot number should be 761");
 183         assertEquals(768, spectrumInformation.getHigherSpectralSlotNumber(), "Higher slot number should be 768");
 184         assertEquals(BigDecimal.valueOf(196.075).setScale(4), spectrumInformation.getMinFrequency(),
 185             "Min freq should be 196.075");
 186         assertEquals(BigDecimal.valueOf(196.125).setScale(4), spectrumInformation.getMaxFrequency(),
 187             "Max freq should be 196.125");
 188     }
 189
 190     @Test
 191     void initSpectrumInformationFromServicePathInputNoFreqTest() {
 192         ServicePathInput input = new ServicePathInputBuilder()
 193                 .setWaveNumber(Uint32.valueOf(1))
 194                 .setHigherSpectralSlotNumber(Uint32.valueOf(768))
 195                 .setLowerSpectralSlotNumber(Uint32.valueOf(761))
 196                 .setNmcWidth(new org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev181019
 197                         .FrequencyGHz(Decimal64.valueOf(GridConstant.WIDTH_40)))
 198                 .build();
 199         SpectrumInformation spectrumInformation = GridUtils.initSpectrumInformationFromServicePathInput(input);
 200         assertEquals(BigDecimal.valueOf(40), spectrumInformation.getWidth(), "Width should be 40");
 201         assertEquals(Uint32.valueOf(1), spectrumInformation.getWaveLength(), "Wavelength should be 1");
 202         assertEquals(BigDecimal.valueOf(196.1).setScale(4), spectrumInformation.getCenterFrequency(),
 203             "Center freq should be 196.1");
 204         assertEquals(761, spectrumInformation.getLowerSpectralSlotNumber(), "Lower slot number should be 761");
 205         assertEquals(768, spectrumInformation.getHigherSpectralSlotNumber(), "Higher slot number should be 768");
 206         assertEquals(BigDecimal.valueOf(196.075).setScale(4), spectrumInformation.getMinFrequency(),
 207             "Min freq should be 196.075");
 208         assertEquals(BigDecimal.valueOf(196.125).setScale(4), spectrumInformation.getMaxFrequency(),
 209             "Max freq should be 196.125");
 210     }
 211
 212     @Test
 213     void initSpectrumInformationFromServicePathInputNoSlotTest() {
 214         IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, () -> {
 215             GridUtils.initSpectrumInformationFromServicePathInput(new ServicePathInputBuilder().build());
 216         });
 217         assertEquals("low and higher spectral slot numbers cannot be null", exception.getMessage());
 218     }
 219 }