src/be/nikiroo/utils/test/BundleTest.java

   1 package be.nikiroo.utils.test;
   2
   3 import java.io.File;
   4 import java.util.ArrayList;
   5 import java.util.List;
   6
   7 import be.nikiroo.utils.IOUtils;
   8 import be.nikiroo.utils.resources.Bundle;
   9 import be.nikiroo.utils.resources.Bundles;
  10 import be.nikiroo.utils.resources.Meta;
  11
  12 class BundleTest extends TestLauncher {
  13         private File tmp;
  14         private B b = new B();
  15
  16         public BundleTest(String[] args) {
  17                 this("Bundle test", args);
  18         }
  19
  20         protected BundleTest(String name, String[] args) {
  21                 super(name, args);
  22
  23                 for (TestCase test : getSimpleTests()) {
  24                         addTest(test);
  25                 }
  26
  27                 addSeries(new TestLauncher("After saving/reloading the resources", args) {
  28                         {
  29                                 for (TestCase test : getSimpleTests()) {
  30                                         addTest(test);
  31                                 }
  32                         }
  33
  34                         @Override
  35                         protected void start() throws Exception {
  36                                 tmp = File.createTempFile("nikiroo-utils", ".test");
  37                                 tmp.delete();
  38                                 tmp.mkdir();
  39                                 b.updateFile(tmp.getAbsolutePath());
  40                                 Bundles.setDirectory(tmp.getAbsolutePath());
  41                                 b.reload(false);
  42                         }
  43
  44                         @Override
  45                         protected void stop() {
  46                                 IOUtils.deltree(tmp);
  47                         }
  48                 });
  49
  50                 addSeries(new TestLauncher("Read/Write support", args) {
  51                         {
  52                                 addTest(new TestCase("Reload") {
  53                                         @Override
  54                                         public void test() throws Exception {
  55                                                 String def = b.getString(E.ONE);
  56                                                 String val = "Something";
  57
  58                                                 b.setString(E.ONE, val);
  59                                                 b.updateFile();
  60                                                 b.reload(true);
  61
  62                                                 assertEquals("We should have reset the bundle", def,
  63                                                                 b.getString(E.ONE));
  64
  65                                                 b.reload(false);
  66
  67                                                 assertEquals("We should have reloaded the same files",
  68                                                                 val, b.getString(E.ONE));
  69
  70                                                 // reset values for next tests
  71                                                 b.reload(true);
  72                                                 b.updateFile();
  73                                         }
  74                                 });
  75
  76                                 addTest(new TestCase("Set/Get") {
  77                                         @Override
  78                                         public void test() throws Exception {
  79                                                 String val = "Newp";
  80                                                 b.setString(E.ONE, val);
  81                                                 String setGet = b.getString(E.ONE);
  82
  83                                                 assertEquals(val, setGet);
  84
  85                                                 // reset values for next tests
  86                                                 b.restoreSnapshot(null);
  87                                         }
  88                                 });
  89
  90                                 addTest(new TestCase("Snapshots") {
  91                                         @Override
  92                                         public void test() throws Exception {
  93                                                 String val = "Newp";
  94                                                 String def = b.getString(E.ONE);
  95
  96                                                 b.setString(E.ONE, val);
  97                                                 Object snap = b.takeSnapshot();
  98
  99                                                 b.restoreSnapshot(null);
 100                                                 assertEquals(
 101                                                                 "restoreChanges(null) should clear the changes",
 102                                                                 def, b.getString(E.ONE));
 103                                                 b.restoreSnapshot(snap);
 104                                                 assertEquals(
 105                                                                 "restoreChanges(snapshot) should restore the changes",
 106                                                                 val, b.getString(E.ONE));
 107
 108                                                 // reset values for next tests
 109                                                 b.restoreSnapshot(null);
 110                                         }
 111                                 });
 112
 113                                 addTest(new TestCase("updateFile with changes") {
 114                                         @Override
 115                                         public void test() throws Exception {
 116                                                 String val = "Go to disk! (UTF-8 test: 日本語)";
 117
 118                                                 String def = b.getString(E.ONE);
 119                                                 b.setString(E.ONE, val);
 120                                                 b.updateFile(tmp.getAbsolutePath());
 121                                                 b.reload(false);
 122
 123                                                 assertEquals(val, b.getString(E.ONE));
 124
 125                                                 // reset values for next tests
 126                                                 b.setString(E.ONE, def);
 127                                                 b.updateFile(tmp.getAbsolutePath());
 128                                                 b.reload(false);
 129                                         }
 130                                 });
 131                         }
 132
 133                         @Override
 134                         protected void start() throws Exception {
 135                                 tmp = File.createTempFile("nikiroo-utils", ".test");
 136                                 tmp.delete();
 137                                 tmp.mkdir();
 138                                 b.updateFile(tmp.getAbsolutePath());
 139                                 Bundles.setDirectory(tmp.getAbsolutePath());
 140                                 b.reload(false);
 141                         }
 142
 143                         @Override
 144                         protected void stop() {
 145                                 IOUtils.deltree(tmp);
 146                         }
 147                 });
 148         }
 149
 150         private List<TestCase> getSimpleTests() {
 151                 String pre = "";
 152
 153                 List<TestCase> list = new ArrayList<TestCase>();
 154
 155                 list.add(new TestCase(pre + "getString simple") {
 156                         @Override
 157                         public void test() throws Exception {
 158                                 assertEquals("un", b.getString(E.ONE));
 159                         }
 160                 });
 161
 162                 list.add(new TestCase(pre + "getStringX with null suffix") {
 163                         @Override
 164                         public void test() throws Exception {
 165                                 assertEquals("un", b.getStringX(E.ONE, null));
 166                         }
 167                 });
 168
 169                 list.add(new TestCase(pre + "getStringX with empty suffix") {
 170                         @Override
 171                         public void test() throws Exception {
 172                                 assertEquals(null, b.getStringX(E.ONE, ""));
 173                         }
 174                 });
 175
 176                 list.add(new TestCase(pre + "getStringX with existing suffix") {
 177                         @Override
 178                         public void test() throws Exception {
 179                                 assertEquals("un + suffix", b.getStringX(E.ONE, "suffix"));
 180                         }
 181                 });
 182
 183                 list.add(new TestCase(pre + "getStringX with not existing suffix") {
 184                         @Override
 185                         public void test() throws Exception {
 186                                 assertEquals(null, b.getStringX(E.ONE, "fake"));
 187                         }
 188                 });
 189
 190                 list.add(new TestCase(pre + "getString with UTF-8 content") {
 191                         @Override
 192                         public void test() throws Exception {
 193                                 assertEquals("日本語 Nihongo", b.getString(E.JAPANESE));
 194                         }
 195                 });
 196
 197                 return list;
 198         }
 199
 200         /**
 201          * {@link Bundle}.
 202          *
 203          * @author niki
 204          */
 205         private class B extends Bundle<E> {
 206                 protected B() {
 207                         super(E.class, N.bundle_test);
 208                 }
 209
 210                 @Override
 211                 // ...and make it public
 212                 public Object takeSnapshot() {
 213                         return super.takeSnapshot();
 214                 }
 215
 216                 @Override
 217                 // ...and make it public
 218                 public void restoreSnapshot(Object snap) {
 219                         super.restoreSnapshot(snap);
 220                 }
 221         }
 222
 223         /**
 224          * Key enum for the {@link Bundle}.
 225          *
 226          * @author niki
 227          */
 228         private enum E {
 229                 @Meta(what = "", where = "", format = "", info = "")
 230                 ONE, //
 231                 @Meta(what = "", where = "", format = "", info = "")
 232                 ONE_SUFFIX, //
 233                 @Meta(what = "", where = "", format = "", info = "")
 234                 TWO, //
 235                 @Meta(what = "", where = "", format = "", info = "")
 236                 JAPANESE
 237         }
 238
 239         /**
 240          * Name enum for the {@link Bundle}.
 241          *
 242          * @author niki
 243          */
 244         private enum N {
 245                 bundle_test
 246         }
 247 }