pythonnet/src/tests/test_compat.py at pytests-core · attackgithub/pythonnet · GitHub

Repository navigation

History

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

# -*- coding: utf-8 -*-

# TODO: Complete removal of methods below. Similar to test_module

"""Backward-compatibility tests for deprecated features."""

import types

import pytest

from ._compat import ClassType, PY2, PY3, range

from .utils import is_clr_class, is_clr_module, is_clr_root_module

# Tests for old-style CLR-prefixed module naming.

def test_simple_import():

"""Test simple import."""

import CLR

assert is_clr_root_module(CLR)

assert CLR.__name__ == 'clr'

import sys

assert isinstance(sys, types.ModuleType)

assert sys.__name__ == 'sys'

if PY3:

import http.client

assert isinstance(http.client, types.ModuleType)

assert http.client.__name__ == 'http.client'

elif PY2:

import httplib

assert isinstance(httplib, types.ModuleType)

assert httplib.__name__ == 'httplib'

def test_simple_import_with_alias():

"""Test simple import with aliasing."""

import CLR as myCLR

assert is_clr_root_module(myCLR)

assert myCLR.__name__ == 'clr'

import sys as mySys

assert isinstance(mySys, types.ModuleType)

assert mySys.__name__ == 'sys'

if PY3:

import http.client as myHttplib

assert isinstance(myHttplib, types.ModuleType)

assert myHttplib.__name__ == 'http.client'

elif PY2:

import httplib as myHttplib

assert isinstance(myHttplib, types.ModuleType)

assert myHttplib.__name__ == 'httplib'

def test_dotted_name_import():

"""Test dotted-name import."""

import CLR.System

assert is_clr_module(CLR.System)

assert CLR.System.__name__ == 'System'

import System

assert is_clr_module(System)

assert System.__name__ == 'System'

assert System is CLR.System

import xml.dom

assert isinstance(xml.dom, types.ModuleType)

assert xml.dom.__name__ == 'xml.dom'

def test_dotted_name_import_with_alias():

"""Test dotted-name import with aliasing."""

import CLR.System as myCLRSystem

assert is_clr_module(myCLRSystem)

assert myCLRSystem.__name__ == 'System'

import System as mySystem

assert is_clr_module(mySystem)

assert mySystem.__name__ == 'System'

assert mySystem is myCLRSystem

import xml.dom as myDom

assert isinstance(myDom, types.ModuleType)

assert myDom.__name__ == 'xml.dom'

def test_simple_import_from():

"""Test simple 'import from'."""

from CLR import System

assert is_clr_module(System)

assert System.__name__ == 'System'

from xml import dom

assert isinstance(dom, types.ModuleType)

assert dom.__name__ == 'xml.dom'

def test_simple_import_from_with_alias():

"""Test simple 'import from' with aliasing."""

from CLR import System as mySystem

assert is_clr_module(mySystem)

assert mySystem.__name__ == 'System'

from xml import dom as myDom

assert isinstance(myDom, types.ModuleType)

assert myDom.__name__ == 'xml.dom'

def test_dotted_name_import_from():

"""Test dotted-name 'import from'."""

# Uses IO instead of Xml

# As it's available from .Net Core 2.0 without an addref

from CLR.System import IO

assert is_clr_module(IO)

assert IO.__name__ == 'System.IO'

from CLR.System.IO import Path

assert is_clr_class(Path)

assert Path.__name__ == 'Path'

from xml.dom import pulldom

assert isinstance(pulldom, types.ModuleType)

assert pulldom.__name__ == 'xml.dom.pulldom'

from xml.dom.pulldom import PullDOM

assert isinstance(PullDOM, ClassType)

assert PullDOM.__name__ == 'PullDOM'

def test_dotted_name_import_from_with_alias():

"""Test dotted-name 'import from' with aliasing."""

# Uses IO instead of Xml

# As it's available from .Net Core 2.0 without an addref

from CLR.System import IO as myIO

assert is_clr_module(myIO)

assert myIO.__name__ == 'System.IO'

from CLR.System.IO import Path as myPath

assert is_clr_class(myPath)

assert myPath.__name__ == 'Path'

from xml.dom import pulldom as myPulldom

assert isinstance(myPulldom, types.ModuleType)

assert myPulldom.__name__ == 'xml.dom.pulldom'

from xml.dom.pulldom import PullDOM as myPullDOM

assert isinstance(myPullDOM, ClassType)

assert myPullDOM.__name__ == 'PullDOM'

def test_from_module_import_star():

"""Test from module import * behavior."""

count = len(locals().keys())

# Uses IO instead of Xml

# As it's available from .Net Core 2.0 without an addref

m = __import__('CLR.System.IO', globals(), locals(), ['*'])

assert m.__name__ == 'System.IO'

assert is_clr_module(m)

assert len(locals().keys()) > count + 1

m2 = __import__('System.IO', globals(), locals(), ['*'])

assert m2.__name__ == 'System.IO'

assert is_clr_module(m2)

assert len(locals().keys()) > count + 1

assert m is m2

def test_explicit_assembly_load():

"""Test explicit assembly loading using standard CLR tools."""

from CLR.System.Reflection import Assembly

from CLR import System

from CLR.System.IO import FileNotFoundException

import sys

assembly = Assembly.LoadWithPartialName('System.IO')

assert assembly is not None

# Uses IO instead of Data

# As it's available from .Net Core 2.0 without an addref

import CLR.System.IO

assert 'System.IO' in sys.modules

# Assembly.LoadWithPartialName is obsolete, and delegates to Assembly.Load

# in .Net Core (which then throws)

# assembly = Assembly.LoadWithPartialName('SpamSpamSpamSpamEggsAndSpam')

# assert assembly is None

with pytest.raises(FileNotFoundException):

assembly = Assembly.LoadFrom('SpamSpamSpamSpamEggsAndSpam')

def test_implicit_load_already_valid_namespace():

"""Test implicit assembly load over an already valid namespace."""

# In this case, the mscorlib assembly (loaded by default) defines

# a number of types in the System namespace. There is also a System

# assembly, which is _not_ loaded by default, which also contains

# types in the System namespace. The desired behavior is for the

# Python runtime to "do the right thing", allowing types from both

# assemblies to be found in the CLR.System module implicitly.

import CLR.System

assert is_clr_class(CLR.System.UriBuilder)

def test_import_non_existant_module():

"""Test import failure for a non-existent module."""

with pytest.raises(ImportError):

import System.SpamSpamSpam

with pytest.raises(ImportError):

import CLR.System.SpamSpamSpam

def test_lookup_no_namespace_type():

"""Test lookup of types without a qualified namespace."""

import CLR.Python.Test

import CLR

assert is_clr_class(CLR.NoNamespaceType)

def test_module_lookup_recursion():

"""Test for recursive lookup handling."""

with pytest.raises(ImportError):

from CLR import CLR

with pytest.raises(AttributeError):

import CLR

_ = CLR.CLR

def test_module_get_attr():

"""Test module getattr behavior."""

import CLR.System as System

int_type = System.Int32

assert is_clr_class(int_type)

# Uses IO instead of Xml

# As it's available from .Net Core 2.0 without an addref

module = System.IO

assert is_clr_module(module)

with pytest.raises(AttributeError):

_ = System.Spam

with pytest.raises(TypeError):

_ = getattr(System, 1)

def test_multiple_imports():

# import CLR did raise a Seg Fault once

# test if the Exceptions.warn() method still causes it

for _ in range(100):

import CLR

_ = CLR

pythonnet/src/tests/test_compat.py at pytests-core · attackgithub/pythonnet · GitHub

Repository navigation

Expand file tree

Breadcrumbs

test_compat.py

Latest commit

History

Breadcrumbs

test_compat.py

File metadata and controls