test_UWI_API_leading_zero() - Code Metrics - Inspection of "Merge pull request #205 from kinverarity1/issue135..." - kinverarity1/lasio - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 4d9cef...837c4f )

by Kent

created 2017-12-02 04:21 UTC

test_UWI_API_leading_zero() A

↳ Parent: Project

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	2
c	0
b	0
f	0
dl	0
loc	3
rs	10

import os, sys; sys.path.insert(0, os.path.dirname(os.path.dirname(__file__)))
import glob
import fnmatch
import traceback
import logging

import numpy
import pytest

import lasio

test_dir = os.path.dirname(__file__)

egfn = lambda fn: os.path.join(os.path.dirname(__file__), "examples", fn)
stegfn = lambda vers, fn: os.path.join(
    os.path.dirname(__file__), "examples", vers, fn)

logger = logging.getLogger(__name__)

def test_read_v12_sample():
    l = lasio.read(stegfn("1.2", "sample.las"))
    

def test_read_v12_sample_big():
    l = lasio.read(stegfn("1.2", "sample_big.las"))


def test_read_v12_sample_curve_api():
    l = lasio.read(stegfn("1.2", "sample_curve_api.las"))


def test_read_v12_sample_minimal():
    l = lasio.read(stegfn("1.2", "sample_minimal.las"))


def test_read_v12_sample_wrapped():
    l = lasio.read(stegfn("1.2", "sample_wrapped.las"))


def test_read_v2_sample():
    l = lasio.read(stegfn("2.0", "sample_2.0.las"))


def test_read_v2_sample_based():
    l = lasio.read(stegfn("2.0", "sample_2.0_based.las"))


def test_read_v2_sample_minimal():
    l = lasio.read(stegfn("2.0", "sample_2.0_minimal.las"))


def test_read_v2_sample_wrapped():
    l = lasio.read(stegfn("2.0", "sample_2.0_wrapped.las"))


def test_dodgy_param_sect():
    with pytest.raises(lasio.exceptions.LASHeaderError):
        l = lasio.read(egfn("dodgy_param_sect.las"))

def test_ignore_header_errors():
    l = lasio.read(egfn("dodgy_param_sect.las"), ignore_header_errors=True)

def test_mnemonic_good():
    l = lasio.read(egfn("mnemonic_good.las"))
    assert [c.mnemonic for c in l.curves] == [
        "DEPT", "DT", "RHOB", "NPHI", "SFLU", "SFLA", "ILM", "ILD"]

def test_mnemonic_duplicate():
    l = lasio.read(egfn("mnemonic_duplicate.las"))
    assert [c.mnemonic for c in l.curves] == [
        "DEPT", "DT", "RHOB", "NPHI", "SFLU:1", "SFLU:2", "ILM", "ILD"]


def test_mnemonic_leading_period():
    l = lasio.read(egfn("mnemonic_leading_period.las"))
    assert [c.mnemonic for c in l.curves] == [
        "DEPT", "DT", "RHOB", "NPHI", "SFLU", "SFLA", "ILM", "ILD"]

def test_mnemonic_missing():
    l = lasio.read(egfn("mnemonic_missing.las"))
    assert [c.mnemonic for c in l.curves] == [
        "DEPT", "DT", "RHOB", "NPHI", "UNKNOWN", "SFLA", "ILM", "ILD"]

def test_mnemonic_missing_multiple():
    l = lasio.read(egfn("mnemonic_missing_multiple.las"))
    assert [c.mnemonic for c in l.curves] == [
        "DEPT", "DT", "RHOB", "NPHI", "UNKNOWN:1", "UNKNOWN:2", "ILM", "ILD"]

def test_multi_curve_mnemonics():
    l = lasio.read(egfn('sample_issue105_a.las'))
    assert l.keys() == [c.mnemonic for c in l.curves] == ['DEPT', 'RHO:1', 'RHO:2', 'RHO:3', 'PHI']


def test_multi_missing_curve_mnemonics():
    l = lasio.read(egfn('sample_issue105_b.las'))
    assert l.keys() == [c.mnemonic for c in l.curves] == ['DEPT', 'UNKNOWN:1', 'UNKNOWN:2', 'UNKNOWN:3', 'PHI']


def test_multi_curve_mnemonics_gr():
    l = lasio.read(egfn('sample_issue105_c.las'))
    assert l.keys() == [c.mnemonic for c in l.curves] == ['DEPT', 'GR:1', 'GR:2', 'GR[0]', 'GR[1]', 'GR[2]', 'GR[3]', 'GR[4]', 'GR[5]']

#  DEPT.M                      :  1  DEPTH
# GR.gAPI: mean gamma ray value
# GR.gAPI: corrected gamma ray value
# GR[0].gAPI: gamma ray image at angle 0 dega
# GR[1].gAPI: gamma ray image at angle 60 dega
# GR[2].gAPI: gamma ray image at angle 120 dega
# GR[3].gAPI: gamma ray image at angle 180 dega
# GR[4].gAPI: gamma ray image at angle 240 dega
# GR[5].gAPI: gamma ray image at angle 300 dega

def test_inf_uwi():
    l = lasio.read(stegfn('2.0', 'sample_2.0_inf_uwi.las'))
    assert l.well['UWI'].value == '300E074350061450'

def test_missing_vers_loads():
    l = lasio.read(egfn("missing_vers.las"))

def test_missing_vers_missing_headeritem():
    l = lasio.read(egfn("missing_vers.las"))
    assert not 'VERS' in l.version

def test_missing_vers_write_version_none_fails():
    l = lasio.read(egfn("missing_vers.las"))
    with pytest.raises(KeyError):
        l.write(sys.stdout, version=None)

def test_missing_vers_write_version_specified_works():
    l = lasio.read(egfn("missing_vers.las"))
    l.write(sys.stdout, version=1.2)
        
def test_missing_wrap_loads():
    l = lasio.read(egfn("missing_wrap.las"))

def test_missing_wrap_missing_headeritem():
    l = lasio.read(egfn("missing_wrap.las"))
    assert not 'WRAP' in l.version

def test_missing_wrap_write_wrap_none_fails():
    l = lasio.read(egfn("missing_wrap.las"))
    with pytest.raises(KeyError):
        l.write(sys.stdout, wrap=None)

def test_missing_wrap_write_wrap_specified_works():
    l = lasio.read(egfn("missing_wrap.las"))
    l.write(sys.stdout, wrap=True)
        
def test_missing_null_loads():
    l = lasio.read(egfn("missing_null.las"))

def test_missing_null_missing_headeritem():
    l = lasio.read(egfn("missing_null.las"))
    assert not 'NULL' in l.well

def test_barebones():
    las = lasio.read(egfn('barebones.las'))
    assert las['DEPT'][1] == 201

def test_barebones_missing_all_sections():
    las = lasio.read(egfn('barebones2.las'))
    assert las.curves[-1].mnemonic == 'UNKNOWN:8'

def test_not_a_las_file():
    with pytest.raises(KeyError):
        las = lasio.read(egfn('not_a_las_file.las'))

def test_comma_decimal_mark_data():
    las = lasio.read(egfn('comma_decimal_mark.las'))
    assert las['SFLU'][1] == 123.42

def test_comma_decimal_mark_params():
    las = lasio.read(egfn('comma_decimal_mark.las'))
    assert las.params['MDEN'].value == 2710.1

def test_missing_a_section():
    las = lasio.read(egfn('missing_a_section.las'))
    assert not hasattr(las, 'data')

def test_blank_line_in_header():
    las = lasio.read(egfn('blank_line.las'))
    assert las.curves[0].mnemonic == 'DEPT'

def test_duplicate_step():
    las = lasio.read(egfn('duplicate_step.las'))
    
def test_blank_line_at_start():
    las = lasio.read(egfn('blank_line_start.las'))
    
def test_missing_STRT_STOP():
    las = lasio.read(egfn('sample_TVD.las'))
    assert len(las.well) == 12

def test_UWI_API_leading_zero():
    las = lasio.read(egfn('UWI_API_leading_zero.las'))
    assert las.well['UWI'].value == '05123370660000'

1			import os, sys; sys.path.insert(0, os.path.dirname(os.path.dirname(__file__)))
2			import glob
3			import fnmatch
4			import traceback
5			import logging
6
7			import numpy
8			import pytest
9
10			import lasio
11
12			test_dir = os.path.dirname(__file__)
13
14			egfn = lambda fn: os.path.join(os.path.dirname(__file__), "examples", fn)
15			stegfn = lambda vers, fn: os.path.join(
16			os.path.dirname(__file__), "examples", vers, fn)
17
18			logger = logging.getLogger(__name__)
19
20			def test_read_v12_sample():
21			l = lasio.read(stegfn("1.2", "sample.las"))
22
23
24			def test_read_v12_sample_big():
25			l = lasio.read(stegfn("1.2", "sample_big.las"))
26
27
28			def test_read_v12_sample_curve_api():
29			l = lasio.read(stegfn("1.2", "sample_curve_api.las"))
30
31
32			def test_read_v12_sample_minimal():
33			l = lasio.read(stegfn("1.2", "sample_minimal.las"))
34
35
36			def test_read_v12_sample_wrapped():
37			l = lasio.read(stegfn("1.2", "sample_wrapped.las"))
38
39
40			def test_read_v2_sample():
41			l = lasio.read(stegfn("2.0", "sample_2.0.las"))
42
43
44			def test_read_v2_sample_based():
45			l = lasio.read(stegfn("2.0", "sample_2.0_based.las"))
46
47
48			def test_read_v2_sample_minimal():
49			l = lasio.read(stegfn("2.0", "sample_2.0_minimal.las"))
50
51
52			def test_read_v2_sample_wrapped():
53			l = lasio.read(stegfn("2.0", "sample_2.0_wrapped.las"))
54
55
56			def test_dodgy_param_sect():
57			with pytest.raises(lasio.exceptions.LASHeaderError):
58			l = lasio.read(egfn("dodgy_param_sect.las"))
59
60			def test_ignore_header_errors():
61			l = lasio.read(egfn("dodgy_param_sect.las"), ignore_header_errors=True)
62
63			def test_mnemonic_good():
64			l = lasio.read(egfn("mnemonic_good.las"))
65			assert [c.mnemonic for c in l.curves] == [
66			"DEPT", "DT", "RHOB", "NPHI", "SFLU", "SFLA", "ILM", "ILD"]
67
68			def test_mnemonic_duplicate():
69			l = lasio.read(egfn("mnemonic_duplicate.las"))
70			assert [c.mnemonic for c in l.curves] == [
71			"DEPT", "DT", "RHOB", "NPHI", "SFLU:1", "SFLU:2", "ILM", "ILD"]
72
73
74			def test_mnemonic_leading_period():
75			l = lasio.read(egfn("mnemonic_leading_period.las"))
76			assert [c.mnemonic for c in l.curves] == [
77			"DEPT", "DT", "RHOB", "NPHI", "SFLU", "SFLA", "ILM", "ILD"]
78
79			def test_mnemonic_missing():
80			l = lasio.read(egfn("mnemonic_missing.las"))
81			assert [c.mnemonic for c in l.curves] == [
82			"DEPT", "DT", "RHOB", "NPHI", "UNKNOWN", "SFLA", "ILM", "ILD"]
83
84			def test_mnemonic_missing_multiple():
85			l = lasio.read(egfn("mnemonic_missing_multiple.las"))
86			assert [c.mnemonic for c in l.curves] == [
87			"DEPT", "DT", "RHOB", "NPHI", "UNKNOWN:1", "UNKNOWN:2", "ILM", "ILD"]
88
89			def test_multi_curve_mnemonics():
90			l = lasio.read(egfn('sample_issue105_a.las'))
91			assert l.keys() == [c.mnemonic for c in l.curves] == ['DEPT', 'RHO:1', 'RHO:2', 'RHO:3', 'PHI']
92
93
94			def test_multi_missing_curve_mnemonics():
95			l = lasio.read(egfn('sample_issue105_b.las'))
96			assert l.keys() == [c.mnemonic for c in l.curves] == ['DEPT', 'UNKNOWN:1', 'UNKNOWN:2', 'UNKNOWN:3', 'PHI']
97
98
99			def test_multi_curve_mnemonics_gr():
100			l = lasio.read(egfn('sample_issue105_c.las'))
101			assert l.keys() == [c.mnemonic for c in l.curves] == ['DEPT', 'GR:1', 'GR:2', 'GR[0]', 'GR[1]', 'GR[2]', 'GR[3]', 'GR[4]', 'GR[5]']
102
103			# DEPT.M : 1 DEPTH
104			# GR.gAPI: mean gamma ray value
105			# GR.gAPI: corrected gamma ray value
106			# GR[0].gAPI: gamma ray image at angle 0 dega
107			# GR[1].gAPI: gamma ray image at angle 60 dega
108			# GR[2].gAPI: gamma ray image at angle 120 dega
109			# GR[3].gAPI: gamma ray image at angle 180 dega
110			# GR[4].gAPI: gamma ray image at angle 240 dega
111			# GR[5].gAPI: gamma ray image at angle 300 dega
112
113			def test_inf_uwi():
114			l = lasio.read(stegfn('2.0', 'sample_2.0_inf_uwi.las'))
115			assert l.well['UWI'].value == '300E074350061450'
116
117			def test_missing_vers_loads():
118			l = lasio.read(egfn("missing_vers.las"))
119
120			def test_missing_vers_missing_headeritem():
121			l = lasio.read(egfn("missing_vers.las"))
122			assert not 'VERS' in l.version
123
124			def test_missing_vers_write_version_none_fails():
125			l = lasio.read(egfn("missing_vers.las"))
126			with pytest.raises(KeyError):
127			l.write(sys.stdout, version=None)
128
129			def test_missing_vers_write_version_specified_works():
130			l = lasio.read(egfn("missing_vers.las"))
131			l.write(sys.stdout, version=1.2)
132
133			def test_missing_wrap_loads():
134			l = lasio.read(egfn("missing_wrap.las"))
135
136			def test_missing_wrap_missing_headeritem():
137			l = lasio.read(egfn("missing_wrap.las"))
138			assert not 'WRAP' in l.version
139
140			def test_missing_wrap_write_wrap_none_fails():
141			l = lasio.read(egfn("missing_wrap.las"))
142			with pytest.raises(KeyError):
143			l.write(sys.stdout, wrap=None)
144
145			def test_missing_wrap_write_wrap_specified_works():
146			l = lasio.read(egfn("missing_wrap.las"))
147			l.write(sys.stdout, wrap=True)
148
149			def test_missing_null_loads():
150			l = lasio.read(egfn("missing_null.las"))
151
152			def test_missing_null_missing_headeritem():
153			l = lasio.read(egfn("missing_null.las"))
154			assert not 'NULL' in l.well
155
156			def test_barebones():
157			las = lasio.read(egfn('barebones.las'))
158			assert las['DEPT'][1] == 201
159
160			def test_barebones_missing_all_sections():
161			las = lasio.read(egfn('barebones2.las'))
162			assert las.curves[-1].mnemonic == 'UNKNOWN:8'
163
164			def test_not_a_las_file():
165			with pytest.raises(KeyError):
166			las = lasio.read(egfn('not_a_las_file.las'))
167
168			def test_comma_decimal_mark_data():
169			las = lasio.read(egfn('comma_decimal_mark.las'))
170			assert las['SFLU'][1] == 123.42
171
172			def test_comma_decimal_mark_params():
173			las = lasio.read(egfn('comma_decimal_mark.las'))
174			assert las.params['MDEN'].value == 2710.1
175
176			def test_missing_a_section():
177			las = lasio.read(egfn('missing_a_section.las'))
178			assert not hasattr(las, 'data')
179
180			def test_blank_line_in_header():
181			las = lasio.read(egfn('blank_line.las'))
182			assert las.curves[0].mnemonic == 'DEPT'
183
184			def test_duplicate_step():
185			las = lasio.read(egfn('duplicate_step.las'))
186
187			def test_blank_line_at_start():
188			las = lasio.read(egfn('blank_line_start.las'))
189
190			def test_missing_STRT_STOP():
191			las = lasio.read(egfn('sample_TVD.las'))
192			assert len(las.well) == 12
193
194			def test_UWI_API_leading_zero():
195			las = lasio.read(egfn('UWI_API_leading_zero.las'))
196			assert las.well['UWI'].value == '05123370660000'

kinverarity1 / lasio

Push — master ( 4d9cef...837c4f )

test_UWI_API_leading_zero() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like