1/* 2 * Copyright (c) 2005, 2015, 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 * @test 26 * @bug 4716807 27 * @summary Test wildcards in ObjectName key properties value part. 28 * @author Luis-Miguel Alventosa 29 * 30 * @run clean ValueWildcardTest 31 * @run build ValueWildcardTest 32 * @run main ValueWildcardTest 33 */ 34 35import java.util.Hashtable; 36import javax.management.ObjectName; 37 38public class ValueWildcardTest { 39 40 private static int createObjectName(int i, 41 String s, 42 String d, 43 String k, 44 String v, 45 Hashtable<String,String> t, 46 boolean plp, 47 boolean pvp) 48 throws Exception { 49 50 System.out.println("----------------------------------------------"); 51 switch (i) { 52 case 1: 53 System.out.println("ObjectName = " + s); 54 break; 55 case 2: 56 System.out.println("ObjectName.Domain = " + d); 57 System.out.println("ObjectName.Key = " + k); 58 System.out.println("ObjectName.Value = " + v); 59 break; 60 case 3: 61 System.out.println("ObjectName.Domain = " + d); 62 System.out.println("ObjectName.Hashtable = " + t); 63 break; 64 default: 65 throw new Exception("Test incorrect: case: " + i); 66 } 67 int error = 0; 68 ObjectName on = null; 69 try { 70 switch (i) { 71 case 1: 72 on = new ObjectName(s); 73 break; 74 case 2: 75 on = new ObjectName(d, k, v); 76 break; 77 case 3: 78 on = new ObjectName(d, t); 79 break; 80 default: 81 throw new Exception("Test incorrect: case: " + i); 82 } 83 System.out.println("Got Expected ObjectName = " + 84 on.getCanonicalName()); 85 boolean isPattern = on.isPattern(); 86 boolean isDomainPattern = on.isDomainPattern(); 87 boolean isPropertyPattern = on.isPropertyPattern(); 88 boolean isPropertyListPattern = on.isPropertyListPattern(); 89 boolean isPropertyValuePattern = on.isPropertyValuePattern(); 90 System.out.println("ObjectName.isPattern = " + 91 isPattern); 92 System.out.println("ObjectName.isDomainPattern = " + 93 isDomainPattern); 94 System.out.println("ObjectName.isPropertyPattern = " + 95 isPropertyPattern); 96 System.out.println("ObjectName.isPropertyListPattern = " + 97 isPropertyListPattern); 98 System.out.println("ObjectName.isPropertyValuePattern = " + 99 isPropertyValuePattern); 100 int error2 = 0; 101 if (isDomainPattern) { 102 error2++; 103 System.out.println("Error: Shouldn't be domain pattern!"); 104 } 105 if (!plp && isPropertyListPattern) { 106 error2++; 107 System.out.println("Error: Shouldn't be property list pattern!"); 108 } 109 if (!pvp && isPropertyValuePattern) { 110 error2++; 111 System.out.println("Error: Shouldn't be property value pattern!"); 112 } 113 if (plp && 114 !isPattern && !isPropertyPattern && !isPropertyListPattern) { 115 error2++; 116 System.out.println("Error: Should be property list pattern!"); 117 } 118 if (pvp && 119 !isPattern && !isPropertyPattern && !isPropertyValuePattern) { 120 error2++; 121 System.out.println("Error: Should be property value pattern!"); 122 } 123 if (error2 > 0) { 124 error++; 125 System.out.println("Test failed!"); 126 } else { 127 System.out.println("Test passed!"); 128 } 129 } catch (Exception e) { 130 error++; 131 System.out.println("Got Unexpected Exception = " + e.toString()); 132 } 133 System.out.println("----------------------------------------------"); 134 return error; 135 } 136 137 private static int createObjectName1(String s, 138 boolean plp, 139 boolean pvp) 140 throws Exception { 141 return createObjectName(1, s, null, null, null, null, plp, pvp); 142 } 143 144 private static int createObjectName2(String d, 145 String k, 146 String v, 147 boolean plp, 148 boolean pvp) 149 throws Exception { 150 return createObjectName(2, null, d, k, v, null, plp, pvp); 151 } 152 153 private static int createObjectName3(String d, 154 Hashtable<String,String> t, 155 boolean plp, 156 boolean pvp) 157 throws Exception { 158 return createObjectName(3, null, d, null, null, t, plp, pvp); 159 } 160 161 public static void main(String[] args) throws Exception { 162 163 int error = 0; 164 165 error += createObjectName1("d:k=*", false, true); 166 error += createObjectName1("d:k=a*b", false, true); 167 error += createObjectName1("d:k=a*b,*", true, true); 168 error += createObjectName1("d:*,k=a*b", true, true); 169 170 error += createObjectName1("d:k=?", false, true); 171 error += createObjectName1("d:k=a?b", false, true); 172 error += createObjectName1("d:k=a?b,*", true, true); 173 error += createObjectName1("d:*,k=a?b", true, true); 174 175 error += createObjectName1("d:k=?*", false, true); 176 error += createObjectName1("d:k=a?bc*d", false, true); 177 error += createObjectName1("d:k=a?bc*d,*", true, true); 178 error += createObjectName1("d:*,k=a?bc*d", true, true); 179 180 error += createObjectName1("d:k1=?,k2=*", false, true); 181 error += createObjectName1("d:k1=a?b,k2=c*d", false, true); 182 error += createObjectName1("d:k1=a?b,k2=c*d,*", true, true); 183 error += createObjectName1("d:*,k1=a?b,k2=c*d", true, true); 184 185 error += createObjectName1("d:k=\"*\"", false, true); 186 error += createObjectName1("d:k=\"a*b\"", false, true); 187 error += createObjectName1("d:k=\"a*b\",*", true, true); 188 error += createObjectName1("d:*,k=\"a*b\"", true, true); 189 190 error += createObjectName1("d:k=\"?\"", false, true); 191 error += createObjectName1("d:k=\"a?b\"", false, true); 192 error += createObjectName1("d:k=\"a?b\",*", true, true); 193 error += createObjectName1("d:*,k=\"a?b\"", true, true); 194 195 error += createObjectName1("d:k=\"?*\"", false, true); 196 error += createObjectName1("d:k=\"a?bc*d\"", false, true); 197 error += createObjectName1("d:k=\"a?bc*d\",*", true, true); 198 error += createObjectName1("d:*,k=\"a?bc*d\"", true, true); 199 200 error += createObjectName1("d:k1=\"?\",k2=\"*\"", false, true); 201 error += createObjectName1("d:k1=\"a?b\",k2=\"c*d\"", false, true); 202 error += createObjectName1("d:k1=\"a?b\",k2=\"c*d\",*", true, true); 203 error += createObjectName1("d:*,k1=\"a?b\",k2=\"c*d\"", true, true); 204 205 error += createObjectName2("d", "k", "*", false, true); 206 error += createObjectName2("d", "k", "a*b", false, true); 207 error += createObjectName2("d", "k", "?", false, true); 208 error += createObjectName2("d", "k", "a?b", false, true); 209 error += createObjectName2("d", "k", "?*", false, true); 210 error += createObjectName2("d", "k", "a?bc*d", false, true); 211 212 error += createObjectName2("d", "k", "\"*\"", false, true); 213 error += createObjectName2("d", "k", "\"a*b\"", false, true); 214 error += createObjectName2("d", "k", "\"?\"", false, true); 215 error += createObjectName2("d", "k", "\"a?b\"", false, true); 216 error += createObjectName2("d", "k", "\"?*\"", false, true); 217 error += createObjectName2("d", "k", "\"a?bc*d\"", false, true); 218 219 Hashtable<String,String> h1 = new Hashtable<String,String>(); 220 h1.put("k", "*"); 221 error += createObjectName3("d", h1, false, true); 222 Hashtable<String,String> h2 = new Hashtable<String,String>(); 223 h2.put("k", "a*b"); 224 error += createObjectName3("d", h2, false, true); 225 226 Hashtable<String,String> h3 = new Hashtable<String,String>(); 227 h3.put("k", "?"); 228 error += createObjectName3("d", h3, false, true); 229 Hashtable<String,String> h4 = new Hashtable<String,String>(); 230 h4.put("k", "a?b"); 231 error += createObjectName3("d", h4, false, true); 232 233 Hashtable<String,String> h5 = new Hashtable<String,String>(); 234 h5.put("k", "?*"); 235 error += createObjectName3("d", h5, false, true); 236 Hashtable<String,String> h6 = new Hashtable<String,String>(); 237 h6.put("k", "a?bc*d"); 238 error += createObjectName3("d", h6, false, true); 239 240 Hashtable<String,String> h7 = new Hashtable<String,String>(); 241 h7.put("k1", "?"); 242 h7.put("k2", "*"); 243 error += createObjectName3("d", h7, false, true); 244 Hashtable<String,String> h8 = new Hashtable<String,String>(); 245 h8.put("k1", "a?b"); 246 h8.put("k2", "c*d"); 247 error += createObjectName3("d", h8, false, true); 248 249 Hashtable<String,String> h9 = new Hashtable<String,String>(); 250 h9.put("k", "\"*\""); 251 error += createObjectName3("d", h9, false, true); 252 Hashtable<String,String> h10 = new Hashtable<String,String>(); 253 h10.put("k", "\"a*b\""); 254 error += createObjectName3("d", h10, false, true); 255 256 Hashtable<String,String> h11 = new Hashtable<String,String>(); 257 h11.put("k", "\"?\""); 258 error += createObjectName3("d", h11, false, true); 259 Hashtable<String,String> h12 = new Hashtable<String,String>(); 260 h12.put("k", "\"a?b\""); 261 error += createObjectName3("d", h12, false, true); 262 263 Hashtable<String,String> h13 = new Hashtable<String,String>(); 264 h13.put("k", "\"?*\""); 265 error += createObjectName3("d", h13, false, true); 266 Hashtable<String,String> h14 = new Hashtable<String,String>(); 267 h14.put("k", "\"a?bc*d\""); 268 error += createObjectName3("d", h14, false, true); 269 270 Hashtable<String,String> h15 = new Hashtable<String,String>(); 271 h15.put("k1", "\"?\""); 272 h15.put("k2", "\"*\""); 273 error += createObjectName3("d", h15, false, true); 274 Hashtable<String,String> h16 = new Hashtable<String,String>(); 275 h16.put("k1", "\"a?b\""); 276 h16.put("k2", "\"c*d\""); 277 error += createObjectName3("d", h16, false, true); 278 279 if (error > 0) { 280 final String msg = "Test FAILED! Got " + error + " error(s)"; 281 System.out.println(msg); 282 throw new IllegalArgumentException(msg); 283 } else { 284 System.out.println("Test PASSED!"); 285 } 286 } 287} 288