# V3157. Suspicious division. Absolute value of the left operand is less than the right operand.

The analyzer has detected one of the two types of integer operations – either a division or modulo operation – in which the absolute value of the left operand is always less than the absolute value of the right operand.

Such operations will return the following results:

- division will always return 0;
- modulo operation will always return the left operand.

Such an expression is very likely to contain an error or is simply redundant.

Consider the following contrived example:

    public void Method()
    {
      int a = 10;
      int b = 20;
      var c = a / b;
      ....
    }

In this snippet, the 'a / b' expression will always evaluate to 0 since 'a < b'. To turn this expression into a real division operation, we need to cast the type of the 'a' variable to 'double':

    public void Method()
    {
      int a = 10;
      int b = 20;
      var c = (double)a / b;
      ....
    }

The following example is taken from a real program:

    public override Shipper CreateInstance(int i)
    {
      ....
      return new Shipper
      {
        ....
        DateCreated = new DateTime(i + 1 % 3000, // <=
                                   (i % 11) + 1,
                                   (i % 27) + 1,
                                   0,
                                   0,
                                   0,
                                   DateTimeKind.Utc),
        ....
      };
    }

The error here has to do with the wrong assumption about operation precedence. In the 'i + 1 % 3000' expression, the '1 % 3000' part will be evaluated first, thus always returning 1. Therefore, the value of the 'i' variable will always be added to 1. This is one way to fix this bug:

    public override Shipper CreateInstance(int i)
    {
      ....
      return new Shipper
      {
        ....
        DateCreated = new DateTime((i + 1) % 3000, // <=
                                   (i % 11) + 1,
                                   (i % 27) + 1,
                                   0,
                                   0,
                                   0,
                                   DateTimeKind.Utc),
        ....
      };
    }

Here is another real-life example:

    private void ValidateMultiRecords(StorageEnvironment env,
                                      IEnumerable<string> trees,
                                      int documentCount,
                                      int i)
    {
      for (var j = 0; j < 10; j++)
      {
        foreach (var treeName in trees)
        {
          var tree = tx.CreateTree(treeName);
          using (var iterator = tree.MultiRead((j % 10).ToString())) // <=
          {
            ....
          }
        }
      }
    }

In this snippet, the 'j' variable is incremented over the range [0..9]. Therefore, the result of the 'j % 10' expression will always be equal to the value of 'j'. This is what the simpler correct version may look like:

    private void ValidateMultiRecords(StorageEnvironment env,
                                      IEnumerable<string> trees,
                                      int documentCount,
                                      int i)
    {
      for (var j = 0; j < 10; j++)
      {
        foreach (var treeName in trees)
        {
          var tree = tx.CreateTree(treeName);
          using (var iterator = tree.MultiRead(j.ToString())) // <=
          {
            ....
          }
        }
      }
    }

This diagnostic is classified as:

CWE-682

You can look at examples of errors detected by the V3157 diagnostic.