nullability/test/comparisons.cc

// Part of the Crubit project, under the Apache License v2.0 with LLVM
// Exceptions. See /LICENSE for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

// Tests for comparisons of types containing nullability annotations.

#include "nullability_test.h"

// nonnull vs nonnull
TEST void nonnullEqualsNonnull(Nonnull<int *> X, Nonnull<int *> Y) {
  nonnull(X);
  nonnull(Y);
  if (X == Y) {
    nonnull(X);
    nonnull(Y);
  } else {
    nonnull(X);
    nonnull(Y);
  }
  nonnull(X);
  nonnull(Y);
}
TEST void nonnullNotEqualsNonnull(Nonnull<int *> X, Nonnull<int *> Y) {
  nonnull(X);
  nonnull(Y);
  if (X != Y) {
    nonnull(X);
    nonnull(Y);
  } else {
    nonnull(X);
    nonnull(Y);
  }
  nonnull(X);
  nonnull(Y);
}

// nullable vs nullable
TEST void nullableEqualsNullable(Nullable<int *> X, Nullable<int *> Y) {
  nullable(X);
  nullable(Y);
  if (X == Y) {
    nullable(X);
    nullable(Y);
  } else {
    nullable(X);
    nullable(Y);
  }
  nullable(X);
  nullable(Y);
}
TEST void nullableNotEqualsNullable(Nullable<int *> X, Nullable<int *> Y) {
  nullable(X);
  nullable(Y);
  if (X != Y) {
    nullable(X);
    nullable(Y);
  } else {
    nullable(X);
    nullable(Y);
  }
  nullable(X);
  nullable(Y);
}

// unknown vs unknown
TEST void unknownEqualsUnknown(int *X, int *Y) {
  unknown(X);
  unknown(Y);
  if (X == Y) {
    unknown(X);
    unknown(Y);
  } else {
    unknown(X);
    unknown(Y);
  }
  unknown(X);
  unknown(Y);
}
TEST void unknownNotEqualsUnknown(int *X, int *Y) {
  unknown(X);
  unknown(Y);
  if (X != Y) {
    unknown(X);
    unknown(Y);
  } else {
    unknown(X);
    unknown(Y);
  }
  unknown(X);
  unknown(Y);
}

// nonnull vs nullptr
// TODO(b/233582219): Implement diagnosis of unreachable program points
TEST void nonnullEqualsNullptr(Nonnull<int *> X) {
  nonnull(X);
  if (X == nullptr) {
    nonnull(X);  // unreachable
  } else {
    nonnull(X);
  }
  nonnull(X);
}
TEST void nullptrEqualsNonnull(Nonnull<int *> X) {
  nonnull(X);
  if (nullptr == X) {
    nonnull(X);  // unreachable
  } else {
    nonnull(X);
  }
  nonnull(X);
}
TEST void nonnullNotEqualsNullptr(Nonnull<int *> X) {
  nonnull(X);
  if (X != nullptr) {
    nonnull(X);
  } else {
    nonnull(X);  // unreachable
  }
  nonnull(X);
}
TEST void nullptrNotEqualsNonnull(Nonnull<int *> X) {
  nonnull(X);
  if (nullptr != X) {
    nonnull(X);
  } else {
    nonnull(X);  // unreachable
  }
  nonnull(X);
}

// nullable vs nullptr
TEST void nullableEqualsNullptr(Nullable<int *> X) {
  nullable(X);
  if (X == nullptr) {
    nullable(X);
  } else {
    nonnull(X);
  }
  nullable(X);
}
TEST void nullptrEqualsNullable(Nullable<int *> X) {
  nullable(X);
  if (nullptr == X) {
    nullable(X);
  } else {
    nonnull(X);
  }
  nullable(X);
}
TEST void nullableNotEqualsNullptr(Nullable<int *> X) {
  nullable(X);
  if (X != nullptr) {
    nonnull(X);
  } else {
    nullable(X);
  }
  nullable(X);
}
TEST void nullptrNotEqualsNullable(Nullable<int *> X) {
  nullable(X);
  if (nullptr != X) {
    nonnull(X);
  } else {
    nullable(X);
  }
  nullable(X);
}

// nullable vs nonnull
TEST void nullableEqualsNonnull(Nullable<int *> X, Nonnull<int *> Y) {
  nullable(X);
  nonnull(Y);
  if (X == Y) {
    nonnull(X);
    nonnull(Y);
  } else {
    nullable(X);
    nonnull(Y);
  }
  nullable(X);
  nonnull(Y);
}
TEST void nonnullEqualsNullable(Nullable<int *> X, Nonnull<int *> Y) {
  nullable(X);
  nonnull(Y);
  if (Y == X) {
    nonnull(X);
    nonnull(Y);
  } else {
    nullable(X);
    nonnull(Y);
  }
  nullable(X);
  nonnull(Y);
}
TEST void nullableNotEqualsNonnull(Nullable<int *> X, Nonnull<int *> Y) {
  nullable(X);
  nonnull(Y);
  if (X != Y) {
    nullable(X);
    nonnull(Y);
  } else {
    nonnull(X);
    nonnull(Y);
  }
  nullable(X);
  nonnull(Y);
}
TEST void nonnullNotEqualsNullable(Nullable<int *> X, Nonnull<int *> Y) {
  nullable(X);
  nonnull(Y);
  if (Y != X) {
    nullable(X);
    nonnull(Y);
  } else {
    nonnull(X);
    nonnull(Y);
  }
  nullable(X);
  nonnull(Y);
}

// nullable vs unknown
TEST void nullableEqualsUnknown(Nullable<int *> X, int *Y) {
  nullable(X);
  unknown(Y);
  if (X == Y) {
    nullable(X);
    unknown(Y);
  } else {
    nullable(X);
    unknown(Y);
  }
  nullable(X);
  unknown(Y);
}
TEST void unknownEqualsNullable(Nullable<int *> X, int *Y) {
  nullable(X);
  unknown(Y);
  if (Y == X) {
    nullable(X);
    unknown(Y);
  } else {
    nullable(X);
    unknown(Y);
  }
  nullable(X);
  unknown(Y);
}
TEST void nullableNotEqualsUnknown(Nullable<int *> X, int *Y) {
  nullable(X);
  unknown(Y);
  if (X != Y) {
    nullable(X);
    unknown(Y);
  } else {
    nullable(X);
    unknown(Y);
  }
  nullable(X);
  unknown(Y);
}
TEST void unknownNotEqualsNullable(Nullable<int *> X, int *Y) {
  nullable(X);
  unknown(Y);
  if (Y != X) {
    nullable(X);
    unknown(Y);
  } else {
    nullable(X);
    unknown(Y);
  }
  nullable(X);
  unknown(Y);
}

// unknown vs nullptr
// TODO(b/233582219): The pointer is compared to nullptr,
// hence the unannotated pointer should be considered nullable.
TEST void unknownEqualsNullptr(int *X) {
  unknown(X);  // TODO: nullable
  if (X == nullptr) {
    nullable(X);
  } else {
    nonnull(X);
  }
  unknown(X);  // TODO: nullable
}
TEST void nullptrEqualsUnknown(int *X) {
  unknown(X);  // TODO: nullable
  if (nullptr == X) {
    nullable(X);
  } else {
    nonnull(X);
  }
  unknown(X);  // TODO: nullable
}
TEST void unknownNotEqualsNullptr(int *X) {
  unknown(X);  // TODO: nullable
  if (X != nullptr) {
    nonnull(X);
  } else {
    nullable(X);
  }
  unknown(X);  // TODO: nullable
}
TEST void nullptrNotEqualsUnknown(int *X) {
  unknown(X);  // TODO: nullable
  if (nullptr != X) {
    nonnull(X);
  } else {
    nullable(X);
  }
  unknown(X);  // TODO: nullable
}

// unknown vs nonnull
TEST void unknownEqualsNonnull(int *X, Nonnull<int *> Y) {
  unknown(X);
  nonnull(Y);
  if (X == Y) {
    nonnull(X);
    nonnull(Y);
  } else {
    unknown(X);
    nonnull(Y);
  }
  unknown(X);
  nonnull(Y);
}
TEST void nonnullEqualsUnknown(int *X, Nonnull<int *> Y) {
  unknown(X);
  nonnull(Y);
  if (Y == X) {
    nonnull(X);
    nonnull(Y);
  } else {
    unknown(X);
    nonnull(Y);
  }
  unknown(X);
  nonnull(Y);
}
TEST void unknownNotEqualsNonnull(int *X, Nonnull<int *> Y) {
  unknown(X);
  nonnull(Y);
  if (X != Y) {
    unknown(X);
    nonnull(Y);
  } else {
    nonnull(X);
    nonnull(Y);
  }
  unknown(X);
  nonnull(Y);
}
TEST void nonnullNotEqualsUnknown(int *X, Nonnull<int *> Y) {
  unknown(X);
  nonnull(Y);
  if (Y != X) {
    unknown(X);
    nonnull(Y);
  } else {
    nonnull(X);
    nonnull(Y);
  }
  unknown(X);
  nonnull(Y);
}