1 /************************************************************** 2 * 3 * Licensed to the Apache Software Foundation (ASF) under one 4 * or more contributor license agreements. See the NOTICE file 5 * distributed with this work for additional information 6 * regarding copyright ownership. The ASF licenses this file 7 * to you under the Apache License, Version 2.0 (the 8 * "License"); you may not use this file except in compliance 9 * with the License. You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, 14 * software distributed under the License is distributed on an 15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 16 * KIND, either express or implied. See the License for the 17 * specific language governing permissions and limitations 18 * under the License. 19 * 20 *************************************************************/ 21 22 23 24 #include "sal/config.h" 25 26 #include <typeinfo> 27 28 namespace salhelper { 29 class Condition; 30 class ConditionModifier; 31 class ConditionWaiter; 32 class ORealDynamicLoader; 33 class SimpleReferenceObject; 34 } 35 36 namespace { 37 38 std::type_info const & getConditionTypeInfo() 39 { return typeid (salhelper::Condition *); } 40 41 std::type_info const & getConditionModifierTypeInfo() 42 { return typeid (salhelper::ConditionModifier *); } 43 44 std::type_info const & getConditionWaiterTypeInfo() 45 { return typeid (salhelper::ConditionWaiter *); } 46 47 std::type_info const & getORealDynamicLoaderTypeInfo() 48 { return typeid (salhelper::ORealDynamicLoader *); } 49 50 std::type_info const & getSimpleReferenceObjectTypeInfo() 51 { return typeid (salhelper::SimpleReferenceObject *); } 52 53 } 54 55 #include "osl/mutex.hxx" 56 #include "salhelper/condition.hxx" 57 #include "salhelper/dynload.hxx" 58 #include "salhelper/simplereferenceobject.hxx" 59 #include "gtest/gtest.h" 60 61 #include <memory> 62 63 namespace { 64 65 class DerivedCondition: public salhelper::Condition { 66 public: 67 explicit DerivedCondition(osl::Mutex & mutex): Condition(mutex) {} 68 69 protected: 70 virtual bool applies() const { return false; } 71 }; 72 73 class DerivedConditionWaiterTimedout: 74 public salhelper::ConditionWaiter::timedout 75 {}; 76 77 class DerivedSimpleReferenceObject: public salhelper::SimpleReferenceObject {}; 78 79 class Test: public ::testing::Test { 80 public: 81 }; 82 83 TEST_F(Test, testCondition) { 84 osl::Mutex mutex; 85 std::auto_ptr< salhelper::Condition > p(new DerivedCondition(mutex)); 86 ASSERT_TRUE(typeid (*p.get()) != typeid (salhelper::Condition)); 87 ASSERT_TRUE(typeid (p.get()) == typeid (salhelper::Condition *)); 88 ASSERT_TRUE( 89 typeid (const_cast< salhelper::Condition const * >(p.get())) 90 == typeid (salhelper::Condition const *)); 91 ASSERT_TRUE( 92 typeid (const_cast< salhelper::Condition volatile * >(p.get())) 93 == typeid (salhelper::Condition volatile *)); 94 ASSERT_TRUE(typeid (salhelper::Condition *) == getConditionTypeInfo()); 95 } 96 97 TEST_F(Test, testConditionModifier) { 98 salhelper::ConditionModifier * p = 0; 99 ASSERT_TRUE(typeid (*p) == typeid (salhelper::ConditionModifier)); 100 ASSERT_TRUE(typeid (p) == typeid (salhelper::ConditionModifier *)); 101 ASSERT_TRUE( 102 typeid (const_cast< salhelper::ConditionModifier const * >(p)) 103 == typeid (salhelper::ConditionModifier const *)); 104 ASSERT_TRUE( 105 typeid (const_cast< salhelper::ConditionModifier volatile * >(p)) 106 == typeid (salhelper::ConditionModifier volatile *)); 107 ASSERT_TRUE( 108 typeid (salhelper::ConditionModifier *) 109 == getConditionModifierTypeInfo()); 110 } 111 112 TEST_F(Test, testConditionWaiter) { 113 salhelper::ConditionWaiter * p = 0; 114 ASSERT_TRUE(typeid (*p) == typeid (salhelper::ConditionWaiter)); 115 ASSERT_TRUE(typeid (p) == typeid (salhelper::ConditionWaiter *)); 116 ASSERT_TRUE( 117 typeid (const_cast< salhelper::ConditionWaiter const * >(p)) 118 == typeid (salhelper::ConditionWaiter const *)); 119 ASSERT_TRUE( 120 typeid (const_cast< salhelper::ConditionWaiter volatile * >(p)) 121 == typeid (salhelper::ConditionWaiter volatile *)); 122 ASSERT_TRUE( 123 typeid (salhelper::ConditionWaiter *) == getConditionWaiterTypeInfo()); 124 } 125 126 TEST_F(Test, testConditionWaiterTimedout) { 127 salhelper::ConditionWaiter::timedout x; 128 ASSERT_TRUE(typeid (x) == typeid (salhelper::ConditionWaiter::timedout)); 129 ASSERT_TRUE( 130 typeid (&x) == typeid (salhelper::ConditionWaiter::timedout *)); 131 ASSERT_TRUE( 132 typeid (const_cast< salhelper::ConditionWaiter::timedout const * >(&x)) 133 == typeid (salhelper::ConditionWaiter::timedout const *)); 134 ASSERT_TRUE( 135 (typeid 136 (const_cast< salhelper::ConditionWaiter::timedout volatile * >(&x))) 137 == typeid (salhelper::ConditionWaiter::timedout volatile *)); 138 try { 139 throw salhelper::ConditionWaiter::timedout(); 140 } catch (salhelper::ConditionWaiter::timedout &) { 141 } catch (...) { 142 FAIL() << "not caught"; 143 } 144 } 145 146 TEST_F(Test, testORealDynamicLoader) { 147 salhelper::ORealDynamicLoader * p = 0; 148 ASSERT_TRUE(typeid (p) != typeid (salhelper::ORealDynamicLoader)); 149 ASSERT_TRUE(typeid (p) == typeid (salhelper::ORealDynamicLoader *)); 150 ASSERT_TRUE( 151 typeid (const_cast< salhelper::ORealDynamicLoader const * >(p)) 152 == typeid (salhelper::ORealDynamicLoader const *)); 153 ASSERT_TRUE( 154 typeid (const_cast< salhelper::ORealDynamicLoader volatile * >(p)) 155 == typeid (salhelper::ORealDynamicLoader volatile *)); 156 ASSERT_TRUE( 157 typeid (salhelper::ORealDynamicLoader *) 158 == getORealDynamicLoaderTypeInfo()); 159 } 160 161 TEST_F(Test, testSimpleReferenceObject) { 162 salhelper::SimpleReferenceObject * p = new DerivedSimpleReferenceObject; 163 try { 164 ASSERT_TRUE( 165 typeid (*p) != typeid (salhelper::SimpleReferenceObject)); 166 ASSERT_TRUE( 167 typeid (p) == typeid (salhelper::SimpleReferenceObject *)); 168 ASSERT_TRUE( 169 typeid (const_cast< salhelper::SimpleReferenceObject const * >(p)) 170 == typeid (salhelper::SimpleReferenceObject const *)); 171 ASSERT_TRUE( 172 (typeid 173 (const_cast< salhelper::SimpleReferenceObject volatile * >(p))) 174 == typeid (salhelper::SimpleReferenceObject volatile *)); 175 ASSERT_TRUE( 176 typeid (salhelper::SimpleReferenceObject *) 177 == getSimpleReferenceObjectTypeInfo()); 178 } catch (...) { 179 delete static_cast< DerivedSimpleReferenceObject * >(p); 180 throw; 181 } 182 } 183 184 TEST_F(Test, testDerivedCondition) { 185 osl::Mutex mutex; 186 std::auto_ptr< salhelper::Condition > p(new DerivedCondition(mutex)); 187 ASSERT_TRUE(dynamic_cast< DerivedCondition * >(p.get()) != 0); 188 } 189 190 TEST_F(Test, testDerivedConditionWaiterTimedout) { 191 std::auto_ptr< salhelper::ConditionWaiter::timedout > p( 192 new DerivedConditionWaiterTimedout); 193 ASSERT_TRUE( 194 dynamic_cast< DerivedConditionWaiterTimedout * >(p.get()) != 0); 195 try { 196 throw DerivedConditionWaiterTimedout(); 197 } catch (salhelper::ConditionWaiter::timedout &) { 198 } catch (...) { 199 FAIL() << "not caught"; 200 } 201 } 202 203 TEST_F(Test, testDerivedSimpleReferenceObject) { 204 salhelper::SimpleReferenceObject * p = new DerivedSimpleReferenceObject; 205 try { 206 ASSERT_TRUE(dynamic_cast< DerivedSimpleReferenceObject * >(p) != 0); 207 } catch (...) { 208 delete static_cast< DerivedSimpleReferenceObject * >(p); 209 throw; 210 } 211 } 212 213 214 } 215