tensorflow/tensorflow

View on GitHub
tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py

Summary

Maintainability
F
1 wk
Test Coverage

File pooling_ops_3d_test.py has 576 lines of code (exceeds 250 allowed). Consider refactoring.
Open

# Copyright 2016 The TensorFlow Authors. All Rights Reserved.
#
# Licensed 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
Severity: Major
Found in tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py - About 1 day to fix

    PoolingTest has 38 functions (exceeds 20 allowed). Consider refactoring.
    Open

    class PoolingTest(test.TestCase):
    
      def _VerifyOneTest(self, pool_func, input_sizes, window, strides, padding,
                         data_format, data_type, expected, use_gpu):
        """Verifies the output values of the pooling function.
    Severity: Minor
    Found in tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py - About 5 hrs to fix

      Function _VerifyOneTest has 9 arguments (exceeds 4 allowed). Consider refactoring.
      Open

        def _VerifyOneTest(self, pool_func, input_sizes, window, strides, padding,
      Severity: Major
      Found in tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py - About 1 hr to fix

        Function _getJacobians has 9 arguments (exceeds 4 allowed). Consider refactoring.
        Open

          def _getJacobians(self,
        Severity: Major
        Found in tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py - About 1 hr to fix

          Function _ConstructAndTestGradientForConfig has 9 arguments (exceeds 4 allowed). Consider refactoring.
          Open

            def _ConstructAndTestGradientForConfig(self, pool_func, input_sizes,
          Severity: Major
          Found in tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py - About 1 hr to fix

            Function _VerifyValues has 6 arguments (exceeds 4 allowed). Consider refactoring.
            Open

              def _VerifyValues(self, pool_func, input_sizes, window, strides,
            Severity: Minor
            Found in tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py - About 45 mins to fix

              Similar blocks of code found in 2 locations. Consider refactoring.
              Open

                def testAvgPool3dSamePadding(self):
                  expected_output = [20.5, 21.5, 22.5, 26.5, 27.5, 28.5]
                  self._VerifyValues(
                      nn_ops.avg_pool3d,
                      input_sizes=[1, 2, 2, 4, 3],
              Severity: Major
              Found in tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py and 1 other location - About 2 hrs to fix
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 202..208

              Duplicated Code

              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

              Tuning

              This issue has a mass of 59.

              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

              Refactorings

              Further Reading

              Similar blocks of code found in 2 locations. Consider refactoring.
              Open

                def testMaxPool3dSamePadding(self):
                  expected_output = [31., 32., 33., 34., 35., 36.]
                  self._VerifyValues(
                      nn_ops.max_pool3d,
                      input_sizes=[1, 2, 2, 3, 3],
              Severity: Major
              Found in tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py and 1 other location - About 2 hrs to fix
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 119..125

              Duplicated Code

              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

              Tuning

              This issue has a mass of 59.

              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

              Refactorings

              Further Reading

              Similar blocks of code found in 19 locations. Consider refactoring.
              Open

                @test_util.run_deprecated_v1
                def testMaxPoolGradValidPadding2_1_6_3d(self):
                  self._ConstructAndTestGradient(
                      nn_ops.max_pool3d,
                      input_sizes=[1, 2, 3, 4, 2],
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 428..435
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 448..455
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 458..465
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 468..475
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 478..485
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 488..495
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 498..505
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 508..515
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 518..525
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 528..535
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 538..545
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 548..555
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 558..565
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 568..575
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 578..585
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 588..595
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 598..605
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 608..615

              Duplicated Code

              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

              Tuning

              This issue has a mass of 57.

              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

              Refactorings

              Further Reading

              Similar blocks of code found in 19 locations. Consider refactoring.
              Open

                @test_util.run_deprecated_v1
                def testAvgPoolGradValidPadding1_1_3d(self):
                  self._ConstructAndTestGradient(
                      nn_ops.avg_pool3d,
                      input_sizes=[1, 3, 3, 3, 1],
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 428..435
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 438..445
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 448..455
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 458..465
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 468..475
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 478..485
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 488..495
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 498..505
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 508..515
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 518..525
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 538..545
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 548..555
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 558..565
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 568..575
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 578..585
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 588..595
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 598..605
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 608..615

              Duplicated Code

              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

              Tuning

              This issue has a mass of 57.

              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

              Refactorings

              Further Reading

              Similar blocks of code found in 19 locations. Consider refactoring.
              Open

                @test_util.run_deprecated_v1
                def testMaxPoolGradValidPadding2_1_7_3d(self):
                  self._ConstructAndTestGradient(
                      nn_ops.max_pool3d,
                      input_sizes=[1, 3, 2, 7, 1],
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 428..435
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 438..445
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 458..465
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 468..475
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 478..485
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 488..495
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 498..505
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 508..515
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 518..525
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 528..535
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 538..545
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 548..555
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 558..565
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 568..575
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 578..585
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 588..595
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 598..605
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 608..615

              Duplicated Code

              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

              Tuning

              This issue has a mass of 57.

              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

              Refactorings

              Further Reading

              Similar blocks of code found in 19 locations. Consider refactoring.
              Open

                @test_util.run_deprecated_v1
                def testAvgPoolGradValidPadding2_1_3d(self):
                  self._ConstructAndTestGradient(
                      nn_ops.avg_pool3d,
                      input_sizes=[1, 3, 3, 3, 2],
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 428..435
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 438..445
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 448..455
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 458..465
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 468..475
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 478..485
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 488..495
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 498..505
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 508..515
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 518..525
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 528..535
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 538..545
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 558..565
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 568..575
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 578..585
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 588..595
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 598..605
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 608..615

              Duplicated Code

              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

              Tuning

              This issue has a mass of 57.

              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

              Refactorings

              Further Reading

              Similar blocks of code found in 19 locations. Consider refactoring.
              Open

                @test_util.run_deprecated_v1
                def testMaxPoolGradSamePadding2_1_3d(self):
                  self._ConstructAndTestGradient(
                      nn_ops.max_pool3d,
                      input_sizes=[1, 3, 2, 4, 1],
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 428..435
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 438..445
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 448..455
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 458..465
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 468..475
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 478..485
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 488..495
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 508..515
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 518..525
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 528..535
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 538..545
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 548..555
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 558..565
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 568..575
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 578..585
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 588..595
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 598..605
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 608..615

              Duplicated Code

              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

              Tuning

              This issue has a mass of 57.

              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

              Refactorings

              Further Reading

              Similar blocks of code found in 19 locations. Consider refactoring.
              Open

                @test_util.run_deprecated_v1
                def testMaxPoolGradValidPadding2_2_3d(self):
                  self._ConstructAndTestGradient(
                      nn_ops.max_pool3d,
                      input_sizes=[2, 2, 2, 2, 1],
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 428..435
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 438..445
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 448..455
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 458..465
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 478..485
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 488..495
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 498..505
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 508..515
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 518..525
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 528..535
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 538..545
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 548..555
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 558..565
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 568..575
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 578..585
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 588..595
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 598..605
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 608..615

              Duplicated Code

              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

              Tuning

              This issue has a mass of 57.

              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

              Refactorings

              Further Reading

              Similar blocks of code found in 19 locations. Consider refactoring.
              Open

                @test_util.run_deprecated_v1
                def testMaxPoolGradSamePadding1_1_3d(self):
                  self._ConstructAndTestGradient(
                      nn_ops.max_pool3d,
                      input_sizes=[1, 3, 2, 4, 1],
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 428..435
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 438..445
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 448..455
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 458..465
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 468..475
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 488..495
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 498..505
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 508..515
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 518..525
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 528..535
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 538..545
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 548..555
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 558..565
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 568..575
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 578..585
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 588..595
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 598..605
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 608..615

              Duplicated Code

              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

              Tuning

              This issue has a mass of 57.

              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

              Refactorings

              Further Reading

              Similar blocks of code found in 19 locations. Consider refactoring.
              Open

                @test_util.run_deprecated_v1
                def testAvgPoolGradSamePadding1_2_3d(self):
                  self._ConstructAndTestGradient(
                      nn_ops.avg_pool3d,
                      input_sizes=[1, 3, 2, 4, 2],
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 428..435
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 438..445
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 448..455
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 458..465
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 468..475
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 478..485
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 488..495
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 498..505
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 508..515
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 518..525
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 528..535
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 538..545
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 548..555
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 558..565
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 568..575
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 588..595
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 598..605
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 608..615

              Duplicated Code

              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

              Tuning

              This issue has a mass of 57.

              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

              Refactorings

              Further Reading

              Similar blocks of code found in 19 locations. Consider refactoring.
              Open

                @test_util.run_deprecated_v1
                def testMaxPoolGradValidPadding1_1_3d(self):
                  self._ConstructAndTestGradient(
                      nn_ops.max_pool3d,
                      input_sizes=[1, 3, 3, 3, 1],
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 438..445
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 448..455
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 458..465
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 468..475
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 478..485
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 488..495
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 498..505
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 508..515
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 518..525
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 528..535
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 538..545
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 548..555
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 558..565
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 568..575
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 578..585
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 588..595
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 598..605
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 608..615

              Duplicated Code

              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

              Tuning

              This issue has a mass of 57.

              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

              Refactorings

              Further Reading

              Similar blocks of code found in 19 locations. Consider refactoring.
              Open

                @test_util.run_deprecated_v1
                def testAvgPoolGradValidPadding1_2_3d(self):
                  self._ConstructAndTestGradient(
                      nn_ops.avg_pool3d,
                      input_sizes=[1, 3, 3, 3, 1],
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 428..435
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 438..445
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 448..455
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 458..465
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 468..475
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 478..485
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 488..495
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 498..505
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 508..515
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 518..525
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 528..535
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 548..555
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 558..565
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 568..575
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 578..585
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 588..595
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 598..605
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 608..615

              Duplicated Code

              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

              Tuning

              This issue has a mass of 57.

              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

              Refactorings

              Further Reading

              Similar blocks of code found in 19 locations. Consider refactoring.
              Open

                @test_util.run_deprecated_v1
                def testMaxPoolGradValidPadding1_2_3d(self):
                  self._ConstructAndTestGradient(
                      nn_ops.max_pool3d,
                      input_sizes=[1, 3, 3, 3, 1],
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 428..435
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 438..445
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 448..455
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 468..475
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 478..485
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 488..495
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 498..505
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 508..515
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 518..525
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 528..535
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 538..545
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 548..555
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 558..565
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 568..575
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 578..585
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 588..595
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 598..605
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 608..615

              Duplicated Code

              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

              Tuning

              This issue has a mass of 57.

              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

              Refactorings

              Further Reading

              Similar blocks of code found in 19 locations. Consider refactoring.
              Open

                @test_util.run_deprecated_v1
                def testMaxPoolGradSamePadding2_2_3d(self):
                  self._ConstructAndTestGradient(
                      nn_ops.max_pool3d,
                      input_sizes=[1, 5, 2, 4, 2],
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 428..435
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 438..445
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 448..455
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 458..465
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 468..475
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 478..485
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 488..495
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 498..505
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 518..525
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 528..535
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 538..545
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 548..555
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 558..565
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 568..575
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 578..585
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 588..595
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 598..605
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 608..615

              Duplicated Code

              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

              Tuning

              This issue has a mass of 57.

              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

              Refactorings

              Further Reading

              Similar blocks of code found in 19 locations. Consider refactoring.
              Open

                @test_util.run_deprecated_v1
                def testAvgPoolGradSamePadding2_2_3d(self):
                  self._ConstructAndTestGradient(
                      nn_ops.avg_pool3d,
                      input_sizes=[1, 5, 2, 4, 1],
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 428..435
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 438..445
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 448..455
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 458..465
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 468..475
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 478..485
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 488..495
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 498..505
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 508..515
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 518..525
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 528..535
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 538..545
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 548..555
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 558..565
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 568..575
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 578..585
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 588..595
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 608..615

              Duplicated Code

              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

              Tuning

              This issue has a mass of 57.

              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

              Refactorings

              Further Reading

              Similar blocks of code found in 19 locations. Consider refactoring.
              Open

                @test_util.run_deprecated_v1
                def testMaxPoolGradSamePadding1_2_3d(self):
                  self._ConstructAndTestGradient(
                      nn_ops.max_pool3d,
                      input_sizes=[1, 3, 2, 4, 1],
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 428..435
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 438..445
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 448..455
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 458..465
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 468..475
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 478..485
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 498..505
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 508..515
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 518..525
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 528..535
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 538..545
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 548..555
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 558..565
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 568..575
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 578..585
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 588..595
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 598..605
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 608..615

              Duplicated Code

              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

              Tuning

              This issue has a mass of 57.

              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

              Refactorings

              Further Reading

              Similar blocks of code found in 19 locations. Consider refactoring.
              Open

                @test_util.run_deprecated_v1
                def testAvgPoolGradSamePadding1_1_3d(self):
                  self._ConstructAndTestGradient(
                      nn_ops.avg_pool3d,
                      input_sizes=[1, 3, 2, 4, 2],
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 428..435
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 438..445
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 448..455
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 458..465
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 468..475
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 478..485
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 488..495
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 498..505
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 508..515
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 518..525
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 528..535
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 538..545
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 548..555
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 558..565
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 578..585
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 588..595
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 598..605
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 608..615

              Duplicated Code

              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

              Tuning

              This issue has a mass of 57.

              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

              Refactorings

              Further Reading

              Similar blocks of code found in 19 locations. Consider refactoring.
              Open

                @test_util.run_deprecated_v1
                def testAvgPoolGradSamePadding3_1_3d(self):
                  self._ConstructAndTestGradient(
                      nn_ops.avg_pool3d,
                      input_sizes=[1, 3, 6, 2, 1],
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 428..435
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 438..445
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 448..455
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 458..465
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 468..475
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 478..485
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 488..495
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 498..505
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 508..515
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 518..525
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 528..535
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 538..545
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 548..555
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 558..565
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 568..575
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 578..585
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 588..595
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 598..605

              Duplicated Code

              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

              Tuning

              This issue has a mass of 57.

              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

              Refactorings

              Further Reading

              Similar blocks of code found in 19 locations. Consider refactoring.
              Open

                @test_util.run_deprecated_v1
                def testMaxPoolGradSamePadding3_1_3d(self):
                  self._ConstructAndTestGradient(
                      nn_ops.max_pool3d,
                      input_sizes=[1, 3, 4, 2, 1],
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 428..435
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 438..445
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 448..455
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 458..465
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 468..475
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 478..485
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 488..495
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 498..505
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 508..515
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 528..535
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 538..545
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 548..555
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 558..565
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 568..575
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 578..585
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 588..595
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 598..605
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 608..615

              Duplicated Code

              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

              Tuning

              This issue has a mass of 57.

              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

              Refactorings

              Further Reading

              Similar blocks of code found in 19 locations. Consider refactoring.
              Open

                @test_util.run_deprecated_v1
                def testAvgPoolGradValidPadding2_2_3d(self):
                  self._ConstructAndTestGradient(
                      nn_ops.avg_pool3d,
                      input_sizes=[2, 2, 2, 2, 2],
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 428..435
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 438..445
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 448..455
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 458..465
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 468..475
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 478..485
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 488..495
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 498..505
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 508..515
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 518..525
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 528..535
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 538..545
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 548..555
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 568..575
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 578..585
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 588..595
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 598..605
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 608..615

              Duplicated Code

              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

              Tuning

              This issue has a mass of 57.

              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

              Refactorings

              Further Reading

              Similar blocks of code found in 19 locations. Consider refactoring.
              Open

                @test_util.run_deprecated_v1
                def testAvgPoolGradSamePadding2_1_3d(self):
                  self._ConstructAndTestGradient(
                      nn_ops.avg_pool3d,
                      input_sizes=[1, 2, 2, 2, 1],
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 428..435
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 438..445
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 448..455
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 458..465
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 468..475
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 478..485
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 488..495
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 498..505
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 508..515
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 518..525
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 528..535
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 538..545
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 548..555
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 558..565
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 568..575
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 578..585
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 598..605
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 608..615

              Duplicated Code

              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

              Tuning

              This issue has a mass of 57.

              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

              Refactorings

              Further Reading

              Similar blocks of code found in 2 locations. Consider refactoring.
              Open

                def testMaxPool3dValidPadding(self):
                  expected_output = [40.0, 41.0, 42.0]
                  self._VerifyValues(
                      nn_ops.max_pool3d,
                      input_sizes=[1, 3, 3, 3, 3],
              Severity: Major
              Found in tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py and 1 other location - About 2 hrs to fix
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 109..115

              Duplicated Code

              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

              Tuning

              This issue has a mass of 56.

              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

              Refactorings

              Further Reading

              Similar blocks of code found in 2 locations. Consider refactoring.
              Open

                def testAvgPool3dValidPadding(self):
                  expected_output = [20.5, 21.5, 22.5]
                  self._VerifyValues(
                      nn_ops.avg_pool3d,
                      input_sizes=[1, 3, 3, 3, 3],
              Severity: Major
              Found in tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py and 1 other location - About 2 hrs to fix
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 192..198

              Duplicated Code

              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

              Tuning

              This issue has a mass of 56.

              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

              Refactorings

              Further Reading

              Similar blocks of code found in 4 locations. Consider refactoring.
              Open

                  self._VerifyValues(
                      nn_ops.avg_pool3d,
                      input_sizes=[1, 7, 7, 7, 1],
                      window=[2, 2, 2],
                      strides=[3, 3, 3],
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 243..249
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 251..257
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 259..265

              Duplicated Code

              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

              Tuning

              This issue has a mass of 50.

              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

              Refactorings

              Further Reading

              Similar blocks of code found in 4 locations. Consider refactoring.
              Open

                  self._VerifyValues(
                      nn_ops.max_pool3d,
                      input_sizes=[1, 3, 3, 3, 1],
                      window=[1, 1, 1],
                      strides=[2, 2, 2],
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 251..257
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 259..265
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 267..273

              Duplicated Code

              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

              Tuning

              This issue has a mass of 50.

              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

              Refactorings

              Further Reading

              Similar blocks of code found in 4 locations. Consider refactoring.
              Open

                  self._VerifyValues(
                      nn_ops.avg_pool3d,
                      input_sizes=[1, 3, 3, 3, 1],
                      window=[1, 1, 1],
                      strides=[2, 2, 2],
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 243..249
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 251..257
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 267..273

              Duplicated Code

              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

              Tuning

              This issue has a mass of 50.

              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

              Refactorings

              Further Reading

              Similar blocks of code found in 4 locations. Consider refactoring.
              Open

                  self._VerifyValues(
                      nn_ops.max_pool3d,
                      input_sizes=[1, 7, 7, 7, 1],
                      window=[2, 2, 2],
                      strides=[3, 3, 3],
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 243..249
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 259..265
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 267..273

              Duplicated Code

              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

              Tuning

              This issue has a mass of 50.

              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

              Refactorings

              Further Reading

              Similar blocks of code found in 3 locations. Consider refactoring.
              Open

              def GetTestConfigs():
                """Get all the valid tests configs to run.
              
                Returns:
                  all the valid test configs as tuples of data_format and use_gpu.
              tensorflow/python/kernel_tests/nn_ops/conv_ops_3d_test.py on lines 90..100
              tensorflow/python/kernel_tests/nn_ops/conv_ops_test.py on lines 147..157

              Duplicated Code

              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

              Tuning

              This issue has a mass of 48.

              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

              Refactorings

              Further Reading

              Similar blocks of code found in 4 locations. Consider refactoring.
              Open

                    with self.assertRaisesRegex(
                        errors_impl.InvalidArgumentError,
                        r"Expected orig_output shape to be \[1,1,1,1,1\], but got "
                        r"\[1,1,1,1,2\]"):
                      gen_nn_ops.max_pool3d_grad_grad(
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 639..645
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 657..662
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 663..668

              Duplicated Code

              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

              Tuning

              This issue has a mass of 46.

              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

              Refactorings

              Further Reading

              Similar blocks of code found in 4 locations. Consider refactoring.
              Open

                    with self.assertRaisesRegex(
                        errors_impl.InvalidArgumentError,
                        r"Expected grad shape to be \[1,1,1,1,1\], but got \[1,1,1,1,2\]"):
                      gen_nn_ops.max_pool3d_grad_grad(
                          orig_in, orig_out, grad, ksize=[1, 1, 1, 1, 1],
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 639..645
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 646..652
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 657..662

              Duplicated Code

              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

              Tuning

              This issue has a mass of 46.

              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

              Refactorings

              Further Reading

              Similar blocks of code found in 4 locations. Consider refactoring.
              Open

                    with self.assertRaisesRegex(
                        errors_impl.InvalidArgumentError,
                        r"Expected grad shape to be \[1,1,1,1,1\], but got \[1,1,1,1,2\]"):
                      gen_nn_ops.max_pool3d_grad(
                          orig_in, orig_out, grad, ksize=[1, 1, 1, 1, 1],
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 639..645
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 646..652
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 663..668

              Duplicated Code

              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

              Tuning

              This issue has a mass of 46.

              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

              Refactorings

              Further Reading

              Similar blocks of code found in 4 locations. Consider refactoring.
              Open

                    with self.assertRaisesRegex(
                        errors_impl.InvalidArgumentError,
                        r"Expected orig_output shape to be \[1,1,1,1,1\], but got "
                        r"\[1,1,1,1,2\]"):
                      gen_nn_ops.max_pool3d_grad(
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 646..652
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 657..662
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 663..668

              Duplicated Code

              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

              Tuning

              This issue has a mass of 46.

              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

              Refactorings

              Further Reading

              Similar blocks of code found in 3 locations. Consider refactoring.
              Open

                    if data_format == "NCDHW":
                      ksize = test_util.NHWCToNCHW(ksize)
                      strides = test_util.NHWCToNCHW(strides)
                      input_tensor = test_util.NHWCToNCHW(input_tensor)
                      output_sizes = test_util.NHWCToNCHW(output_sizes)
              tensorflow/python/kernel_tests/linalg/sparse/conjugate_gradient_test.py on lines 53..57
              tensorflow/python/ops/accumulate_n_benchmark.py on lines 93..97

              Duplicated Code

              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

              Tuning

              This issue has a mass of 45.

              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

              Refactorings

              Further Reading

              Similar blocks of code found in 2 locations. Consider refactoring.
              Open

                    if data_format == "NCDHW":
                      t = test_util.NHWCToNCHW(t)
                      window = test_util.NHWCToNCHW(window)
                      strides = test_util.NHWCToNCHW(strides)
              tensorflow/python/kernel_tests/nn_ops/conv_ops_test.py on lines 1690..1693

              Duplicated Code

              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

              Tuning

              This issue has a mass of 43.

              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

              Refactorings

              Further Reading

              Similar blocks of code found in 2 locations. Consider refactoring.
              Open

                      t = gen_nn_ops.AvgPool3DGrad(
                          orig_input_shape=orig_input_shape,
                          grad=grad,
                          ksize=[1, 1, 1, 1, 1],
                          strides=[1, 1, 1, 1, 1],
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 182..186

              Duplicated Code

              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

              Tuning

              This issue has a mass of 40.

              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

              Refactorings

              Further Reading

              Similar blocks of code found in 2 locations. Consider refactoring.
              Open

                        t = gen_nn_ops.AvgPool3DGrad(
                            orig_input_shape=orig_input_shape,
                            grad=grad,
                            ksize=[1, -3, 1, 1, 1],
                            strides=[1, 1, 1, 1, 1],
              tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py on lines 165..169

              Duplicated Code

              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

              Tuning

              This issue has a mass of 40.

              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

              Refactorings

              Further Reading

              Similar blocks of code found in 3 locations. Consider refactoring.
              Open

                  input_data = np.pad(input_data, [[0, 0], [0, 1], [0, 1], [0, 0]],
              Severity: Minor
              Found in tensorflow/python/kernel_tests/nn_ops/pooling_ops_3d_test.py and 2 other locations - About 35 mins to fix
              tensorflow/python/tools/optimize_for_inference_test.py on lines 422..422
              tensorflow/python/tools/optimize_for_inference_test.py on lines 481..481

              Duplicated Code

              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

              Tuning

              This issue has a mass of 33.

              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

              Refactorings

              Further Reading

              There are no issues that match your filters.

              Category
              Status