1 /* 2 * Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. 8 * 9 * This code is distributed in the hope that it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 12 * version 2 for more details (a copy is included in the LICENSE file that 13 * accompanied this code). 14 * 15 * You should have received a copy of the GNU General Public License version 16 * 2 along with this work; if not, write to the Free Software Foundation, 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 18 * 19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 20 * or visit www.oracle.com if you need additional information or have any 21 * questions. 22 */ 23 24 /* 25 * This file is available under and governed by the GNU General Public 26 * License version 2 only, as published by the Free Software Foundation. 27 * However, the following notice accompanied the original version of this 28 * file: 29 * 30 * Copyright (c) 2009-2012, Stephen Colebourne & Michael Nascimento Santos 31 * 32 * All rights reserved. 33 * 34 * Redistribution and use in source and binary forms, with or without 35 * modification, are permitted provided that the following conditions are met: 36 * 37 * * Redistributions of source code must retain the above copyright notice, 38 * this list of conditions and the following disclaimer. 39 * 40 * * Redistributions in binary form must reproduce the above copyright notice, 41 * this list of conditions and the following disclaimer in the documentation 42 * and/or other materials provided with the distribution. 43 * 44 * * Neither the name of JSR-310 nor the names of its contributors 45 * may be used to endorse or promote products derived from this software 46 * without specific prior written permission. 47 * 48 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 49 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 50 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 51 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR 52 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 53 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 54 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 55 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 56 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 57 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 58 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 59 */ 60 package tck.java.time.zone; 61 62 import static org.testng.Assert.assertEquals; 63 import static org.testng.Assert.assertNotNull; 64 import static org.testng.Assert.assertTrue; 65 66 import java.time.ZoneId; 67 import java.time.ZoneOffset; 68 import java.time.zone.ZoneRules; 69 import java.time.zone.ZoneRulesException; 70 import java.time.zone.ZoneRulesProvider; 71 import java.util.Collections; 72 import java.util.HashSet; 73 import java.util.NavigableMap; 74 import java.util.Set; 75 import java.util.TreeMap; 76 77 import org.testng.annotations.Test; 78 79 /** 80 * Test ZoneRulesProvider. 81 */ 82 @Test 83 public class TCKZoneRulesProvider { 84 85 private static String TZDB_VERSION = "2012i"; 86 87 //----------------------------------------------------------------------- 88 // getAvailableZoneIds() 89 //----------------------------------------------------------------------- 90 @Test test_getAvailableGroupIds()91 public void test_getAvailableGroupIds() { 92 Set<String> zoneIds = ZoneRulesProvider.getAvailableZoneIds(); 93 assertEquals(zoneIds.contains("Europe/London"), true); 94 zoneIds.clear(); 95 assertEquals(zoneIds.size(), 0); 96 Set<String> zoneIds2 = ZoneRulesProvider.getAvailableZoneIds(); 97 assertEquals(zoneIds2.contains("Europe/London"), true); 98 } 99 100 //----------------------------------------------------------------------- 101 // getRules(String, boolean) 102 //----------------------------------------------------------------------- 103 @Test test_getRules_StringBoolean()104 public void test_getRules_StringBoolean() { 105 ZoneRules rules = ZoneRulesProvider.getRules("Europe/London", false); 106 assertNotNull(rules); 107 ZoneRules rules2 = ZoneRulesProvider.getRules("Europe/London", false); 108 assertEquals(rules2, rules); 109 } 110 111 @Test(expectedExceptions=ZoneRulesException.class) test_getRules_StringBoolean_unknownId()112 public void test_getRules_StringBoolean_unknownId() { 113 ZoneRulesProvider.getRules("Europe/Lon", false); 114 } 115 116 @Test(expectedExceptions=NullPointerException.class) test_getRules_StringBoolean_null()117 public void test_getRules_StringBoolean_null() { 118 ZoneRulesProvider.getRules(null, false); 119 } 120 121 @Test test_getRules_StringBoolean_dynamic()122 public void test_getRules_StringBoolean_dynamic() { 123 MockDynamicProvider dynamicProvider = new MockDynamicProvider(); 124 ZoneRulesProvider.registerProvider(dynamicProvider); 125 126 assertEquals(dynamicProvider.count, 0); 127 ZoneRules rules1 = ZoneId.of("DynamicLocation").getRules(); 128 assertEquals(dynamicProvider.count, 2); 129 assertEquals(rules1, dynamicProvider.BASE); 130 ZoneRules rules2 = ZoneId.of("DynamicLocation").getRules(); 131 assertEquals(dynamicProvider.count, 4); 132 assertEquals(rules2, dynamicProvider.ALTERNATE); 133 } 134 135 //----------------------------------------------------------------------- 136 // getVersions(String) 137 //----------------------------------------------------------------------- 138 @Test test_getVersions_String()139 public void test_getVersions_String() { 140 NavigableMap<String, ZoneRules> versions = ZoneRulesProvider.getVersions("Europe/London"); 141 assertTrue(versions.size() >= 1); 142 ZoneRules rules = ZoneRulesProvider.getRules("Europe/London", false); 143 assertEquals(versions.lastEntry().getValue(), rules); 144 145 NavigableMap<String, ZoneRules> copy = new TreeMap<>(versions); 146 versions.clear(); 147 assertEquals(versions.size(), 0); 148 NavigableMap<String, ZoneRules> versions2 = ZoneRulesProvider.getVersions("Europe/London"); 149 assertEquals(versions2, copy); 150 } 151 152 @Test(expectedExceptions=ZoneRulesException.class) test_getVersions_String_unknownId()153 public void test_getVersions_String_unknownId() { 154 ZoneRulesProvider.getVersions("Europe/Lon"); 155 } 156 157 @Test(expectedExceptions=NullPointerException.class) test_getVersions_String_null()158 public void test_getVersions_String_null() { 159 ZoneRulesProvider.getVersions(null); 160 } 161 162 //----------------------------------------------------------------------- 163 // refresh() 164 //----------------------------------------------------------------------- 165 @Test test_refresh()166 public void test_refresh() { 167 assertEquals(ZoneRulesProvider.refresh(), false); 168 } 169 170 //----------------------------------------------------------------------- 171 // registerProvider() 172 //----------------------------------------------------------------------- 173 @Test test_registerProvider()174 public void test_registerProvider() { 175 Set<String> pre = ZoneRulesProvider.getAvailableZoneIds(); 176 assertEquals(pre.contains("FooLocation"), false); 177 ZoneRulesProvider.registerProvider(new MockTempProvider()); 178 assertEquals(pre.contains("FooLocation"), false); 179 Set<String> post = ZoneRulesProvider.getAvailableZoneIds(); 180 assertEquals(post.contains("FooLocation"), true); 181 assertEquals(ZoneRulesProvider.getRules("FooLocation", false), ZoneOffset.of("+01:45").getRules()); 182 } 183 184 static class MockTempProvider extends ZoneRulesProvider { 185 final ZoneRules rules = ZoneOffset.of("+01:45").getRules(); 186 @Override provideZoneIds()187 public Set<String> provideZoneIds() { 188 return new HashSet<String>(Collections.singleton("FooLocation")); 189 } 190 @Override provideVersions(String zoneId)191 protected NavigableMap<String, ZoneRules> provideVersions(String zoneId) { 192 NavigableMap<String, ZoneRules> result = new TreeMap<>(); 193 result.put("BarVersion", rules); 194 return result; 195 } 196 @Override provideRules(String zoneId, boolean forCaching)197 protected ZoneRules provideRules(String zoneId, boolean forCaching) { 198 if (zoneId.equals("FooLocation")) { 199 return rules; 200 } 201 throw new ZoneRulesException("Invalid"); 202 } 203 } 204 205 static class MockDynamicProvider extends ZoneRulesProvider { 206 final ZoneRules BASE = ZoneOffset.of("+01:15").getRules(); 207 final ZoneRules ALTERNATE = ZoneOffset.of("+01:30").getRules(); 208 int count = 0; 209 @Override provideZoneIds()210 public Set<String> provideZoneIds() { 211 return new HashSet<>(Collections.singleton("DynamicLocation")); 212 } 213 @Override provideVersions(String zoneId)214 protected NavigableMap<String, ZoneRules> provideVersions(String zoneId) { 215 NavigableMap<String, ZoneRules> result = new TreeMap<>(); 216 result.put("DynamicVersion1", BASE); 217 if (count > 2) { 218 result.put("DynamicVersion2", ALTERNATE); 219 } 220 return result; 221 } 222 @Override provideRules(String zoneId, boolean forCaching)223 protected ZoneRules provideRules(String zoneId, boolean forCaching) { 224 count++; 225 if (zoneId.equals("DynamicLocation")) { 226 return (forCaching ? null : (count > 2 ? ALTERNATE : BASE)); 227 } 228 throw new ZoneRulesException("Invalid"); 229 } 230 } 231 232 } 233