Hide keyboard shortcuts

Hot-keys on this page

r m x p   toggle line displays

j k   next/prev highlighted chunk

0   (zero) top of page

1   (one) first highlighted chunk

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

# 

# Licensed to the Apache Software Foundation (ASF) under one or more 

# contributor license agreements. See the NOTICE file distributed with 

# this work for additional information regarding copyright ownership. 

# The ASF licenses this file to You under the Apache License, Version 2.0 

# (the "License"); you may not use this file except in compliance with 

# the License. You may obtain a copy of the License at 

# 

# http://www.apache.org/licenses/LICENSE-2.0 

# 

# Unless required by applicable law or agreed to in writing, software 

# distributed under the License is distributed on an "AS IS" BASIS, 

# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 

# See the License for the specific language governing permissions and 

# limitations under the License. 

# 

import unittest 

 

from py4j.protocol import Py4JJavaError 

 

from pyspark import keyword_only 

from pyspark.testing.utils import PySparkTestCase 

 

 

class KeywordOnlyTests(unittest.TestCase): 

class Wrapped(object): 

@keyword_only 

def set(self, x=None, y=None): 

29 ↛ 30line 29 didn't jump to line 30, because the condition on line 29 was never true if "x" in self._input_kwargs: 

self._x = self._input_kwargs["x"] 

31 ↛ 33line 31 didn't jump to line 33, because the condition on line 31 was never false if "y" in self._input_kwargs: 

self._y = self._input_kwargs["y"] 

return x, y 

 

def test_keywords(self): 

w = self.Wrapped() 

x, y = w.set(y=1) 

self.assertEqual(y, 1) 

self.assertEqual(y, w._y) 

self.assertIsNone(x) 

self.assertFalse(hasattr(w, "_x")) 

 

def test_non_keywords(self): 

w = self.Wrapped() 

self.assertRaises(TypeError, lambda: w.set(0, y=1)) 

 

def test_kwarg_ownership(self): 

# test _input_kwargs is owned by each class instance and not a shared static variable 

class Setter(object): 

@keyword_only 

def set(self, x=None, other=None, other_x=None): 

if "other" in self._input_kwargs: 

self._input_kwargs["other"].set(x=self._input_kwargs["other_x"]) 

self._x = self._input_kwargs["x"] 

 

a = Setter() 

b = Setter() 

a.set(x=1, other=b, other_x=2) 

self.assertEqual(a._x, 1) 

self.assertEqual(b._x, 2) 

 

 

class UtilTests(PySparkTestCase): 

def test_py4j_str(self): 

with self.assertRaises(Py4JJavaError) as context: 

# This attempts java.lang.String(null) which throws an NPE. 

self.sc._jvm.java.lang.String(None) 

 

self.assertTrue('NullPointerException' in str(context.exception)) 

 

def test_parsing_version_string(self): 

from pyspark.util import VersionUtils 

self.assertRaises(ValueError, lambda: VersionUtils.majorMinorVersion("abced")) 

 

 

if __name__ == "__main__": 

from pyspark.tests.test_util import * # noqa: F401 

 

try: 

import xmlrunner # type: ignore[import] 

testRunner = xmlrunner.XMLTestRunner(output='target/test-reports', verbosity=2) 

except ImportError: 

testRunner = None 

unittest.main(testRunner=testRunner, verbosity=2)