yosql-codegen/src/test/java/wtf/metio/yosql/codegen/blocks/DefaultVariablesTest.java

   1 /*
   2  * This file is part of yosql. It is subject to the license terms in the LICENSE file found in the top-level
   3  * directory of this distribution and at https://creativecommons.org/publicdomain/zero/1.0/. No part of yosql,
   4  * including this file, may be copied, modified, propagated, or distributed except according to the terms contained
   5  * in the LICENSE file.
   6  */
   7
   8 package wtf.metio.yosql.codegen.blocks;
   9
  10 import org.junit.jupiter.api.Assertions;
  11 import org.junit.jupiter.api.DisplayName;
  12 import org.junit.jupiter.api.Nested;
  13 import org.junit.jupiter.api.Test;
  14 import wtf.metio.yosql.testing.configs.JavaConfigurations;
  15
  16 @DisplayName("DefaultVariables")
  17 class DefaultVariablesTest {
  18
  19     @Nested
  20     @DisplayName("using default configuration")
  21     class JavaDefaultsTest {
  22
  23         @Test
  24         @DisplayName("creates variables")
  25         void shouldCreateVariable() {
  26             // given
  27             final var variables = new DefaultVariables(JavaConfigurations.defaults());
  28
  29             // when
  30             final var variable = variables.inline(String.class, "test");
  31
  32             // then
  33             Assertions.assertEquals("""
  34                     final java.lang.String test""", variable.toString());
  35         }
  36
  37         @Test
  38         @DisplayName("creates variables with initializer")
  39         void shouldCreateVariableWithInitializer() {
  40             // given
  41             final var variables = new DefaultVariables(JavaConfigurations.defaults());
  42
  43             // when
  44             final var variable = variables.inline(String.class, "test", CodeBlocks.code("$S", "hello world"));
  45
  46             // then
  47             Assertions.assertEquals("""
  48                     final var test = "hello world" """, variable.toString());
  49         }
  50
  51         @Test
  52         @DisplayName("creates variable statements")
  53         void shouldCreateVariableStatement() {
  54             // given
  55             final var variables = new DefaultVariables(JavaConfigurations.defaults());
  56
  57             // when
  58             final var variable = variables.statement(String.class, "test", CodeBlocks.code("$S", "hello world"));
  59
  60             // then
  61             Assertions.assertEquals("""
  62                     final var test = "hello world";
  63                     """, variable.toString());
  64         }
  65
  66     }
  67
  68     @Nested
  69     @DisplayName("using Java 8 configuration")
  70     class Java8Test {
  71
  72         @Test
  73         @DisplayName("creates variables")
  74         void shouldCreateVariable() {
  75             // given
  76             final var variables = new DefaultVariables(JavaConfigurations.java8());
  77
  78             // when
  79             final var variable = variables.inline(String.class, "test");
  80
  81             // then
  82             Assertions.assertEquals("""
  83                     final java.lang.String test""", variable.toString());
  84         }
  85
  86         @Test
  87         @DisplayName("creates variables with initializer")
  88         void shouldCreateVariableWithInitializer() {
  89             // given
  90             final var variables = new DefaultVariables(JavaConfigurations.java8());
  91
  92             // when
  93             final var variable = variables.inline(String.class, "test", CodeBlocks.code("$S", "hello world"));
  94
  95             // then
  96             Assertions.assertEquals("""
  97                     final java.lang.String test = "hello world" """, variable.toString());
  98         }
  99
 100         @Test
 101         @DisplayName("creates variable statements")
 102         void shouldCreateVariableStatement() {
 103             // given
 104             final var variables = new DefaultVariables(JavaConfigurations.java8());
 105
 106             // when
 107             final var variable = variables.statement(String.class, "test", CodeBlocks.code("$S", "hello world"));
 108
 109             // then
 110             Assertions.assertEquals("""
 111                     final java.lang.String test = "hello world";
 112                     """, variable.toString());
 113         }
 114
 115     }
 116
 117     @Nested
 118     @DisplayName("using Java 9 configuration")
 119     class Java9Test {
 120
 121         @Test
 122         @DisplayName("creates variables")
 123         void shouldCreateVariable() {
 124             // given
 125             final var variables = new DefaultVariables(JavaConfigurations.java9());
 126
 127             // when
 128             final var variable = variables.inline(String.class, "test");
 129
 130             // then
 131             Assertions.assertEquals("""
 132                     final java.lang.String test""", variable.toString());
 133         }
 134
 135         @Test
 136         @DisplayName("creates variables with initializer")
 137         void shouldCreateVariableWithInitializer() {
 138             // given
 139             final var variables = new DefaultVariables(JavaConfigurations.java9());
 140
 141             // when
 142             final var variable = variables.inline(String.class, "test", CodeBlocks.code("$S", "hello world"));
 143
 144             // then
 145             Assertions.assertEquals("""
 146                     final java.lang.String test = "hello world" """, variable.toString());
 147         }
 148
 149         @Test
 150         @DisplayName("creates variable statements")
 151         void shouldCreateVariableStatement() {
 152             // given
 153             final var variables = new DefaultVariables(JavaConfigurations.java9());
 154
 155             // when
 156             final var variable = variables.statement(String.class, "test", CodeBlocks.code("$S", "hello world"));
 157
 158             // then
 159             Assertions.assertEquals("""
 160                     final java.lang.String test = "hello world";
 161                     """, variable.toString());
 162         }
 163
 164     }
 165
 166     @Nested
 167     @DisplayName("using Java 11 configuration")
 168     class Java11Test {
 169
 170         @Test
 171         @DisplayName("creates variables")
 172         void shouldCreateVariable() {
 173             // given
 174             final var variables = new DefaultVariables(JavaConfigurations.java11());
 175
 176             // when
 177             final var variable = variables.inline(String.class, "test");
 178
 179             // then
 180             Assertions.assertEquals("""
 181                     final java.lang.String test""", variable.toString());
 182         }
 183
 184         @Test
 185         @DisplayName("creates variables with initializer")
 186         void shouldCreateVariableWithInitializer() {
 187             // given
 188             final var variables = new DefaultVariables(JavaConfigurations.java11());
 189
 190             // when
 191             final var variable = variables.inline(String.class, "test", CodeBlocks.code("$S", "hello world"));
 192
 193             // then
 194             Assertions.assertEquals("""
 195                     final var test = "hello world" """, variable.toString());
 196         }
 197
 198         @Test
 199         @DisplayName("creates variable statements")
 200         void shouldCreateVariableStatement() {
 201             // given
 202             final var variables = new DefaultVariables(JavaConfigurations.java11());
 203
 204             // when
 205             final var variable = variables.statement(String.class, "test", CodeBlocks.code("$S", "hello world"));
 206
 207             // then
 208             Assertions.assertEquals("""
 209                     final var test = "hello world";
 210                     """, variable.toString());
 211         }
 212
 213     }
 214
 215     @Nested
 216     @DisplayName("using Java 14 configuration")
 217     class Java14Test {
 218
 219         @Test
 220         @DisplayName("creates variables")
 221         void shouldCreateVariable() {
 222             // given
 223             final var variables = new DefaultVariables(JavaConfigurations.java14());
 224
 225             // when
 226             final var variable = variables.inline(String.class, "test");
 227
 228             // then
 229             Assertions.assertEquals("""
 230                     final java.lang.String test""", variable.toString());
 231         }
 232
 233         @Test
 234         @DisplayName("creates variables with initializer")
 235         void shouldCreateVariableWithInitializer() {
 236             // given
 237             final var variables = new DefaultVariables(JavaConfigurations.java14());
 238
 239             // when
 240             final var variable = variables.inline(String.class, "test", CodeBlocks.code("$S", "hello world"));
 241
 242             // then
 243             Assertions.assertEquals("""
 244                     final var test = "hello world" """, variable.toString());
 245         }
 246
 247         @Test
 248         @DisplayName("creates variable statements")
 249         void shouldCreateVariableStatement() {
 250             // given
 251             final var variables = new DefaultVariables(JavaConfigurations.java14());
 252
 253             // when
 254             final var variable = variables.statement(String.class, "test", CodeBlocks.code("$S", "hello world"));
 255
 256             // then
 257             Assertions.assertEquals("""
 258                     final var test = "hello world";
 259                     """, variable.toString());
 260         }
 261
 262     }
 263
 264     @Nested
 265     @DisplayName("using Java 16 configuration")
 266     class Java16Test {
 267
 268         @Test
 269         @DisplayName("creates variables")
 270         void shouldCreateVariable() {
 271             // given
 272             final var variables = new DefaultVariables(JavaConfigurations.java16());
 273
 274             // when
 275             final var variable = variables.inline(String.class, "test");
 276
 277             // then
 278             Assertions.assertEquals("""
 279                     final java.lang.String test""", variable.toString());
 280         }
 281
 282         @Test
 283         @DisplayName("creates variables with initializer")
 284         void shouldCreateVariableWithInitializer() {
 285             // given
 286             final var variables = new DefaultVariables(JavaConfigurations.java16());
 287
 288             // when
 289             final var variable = variables.inline(String.class, "test", CodeBlocks.code("$S", "hello world"));
 290
 291             // then
 292             Assertions.assertEquals("""
 293                     final var test = "hello world" """, variable.toString());
 294         }
 295
 296         @Test
 297         @DisplayName("creates variable statements")
 298         void shouldCreateVariableStatement() {
 299             // given
 300             final var variables = new DefaultVariables(JavaConfigurations.java16());
 301
 302             // when
 303             final var variable = variables.statement(String.class, "test", CodeBlocks.code("$S", "hello world"));
 304
 305             // then
 306             Assertions.assertEquals("""
 307                     final var test = "hello world";
 308                     """, variable.toString());
 309         }
 310
 311     }
 312
 313 }