"NULL !=" = NULL

tests/TextureCompressionTest.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkBitmap.h"
 #include "SkData.h"
 #include "SkEndian.h"
@@ skipping 116 matching lines @@
     REPORTER_ASSERT(reporter, setInfoSuccess);
 
     bitmap.allocPixels(info);
     bitmap.unlockPixels();
 
     // Populate bitmap
     {
         SkAutoLockPixels alp(bitmap);
 
         uint8_t* pixels = reinterpret_cast<uint8_t*>(bitmap.getPixels());
-        REPORTER_ASSERT(reporter, NULL != pixels);
+        REPORTER_ASSERT(reporter, pixels);
         if (NULL == pixels) {
             return;
         }
 
         for (int y = 0; y < kHeight; ++y) {
             for (int x = 0; x < kWidth; ++x) {
                 if ((x ^ y) & 1) {
                     pixels[x] = 0xFF;
                 } else {
                     pixels[x] = 0;
                 }
             }
             pixels += bitmap.rowBytes();
         }
     }
 
     SkAutoMalloc decompMemory(kWidth*kHeight);
     uint8_t* decompBuffer = reinterpret_cast<uint8_t*>(decompMemory.get());
-    REPORTER_ASSERT(reporter, NULL != decompBuffer);
+    REPORTER_ASSERT(reporter, decompBuffer);
     if (NULL == decompBuffer) {
         return;
     }
 
     for (int i = 0; i < SkTextureCompressor::kFormatCnt; ++i) {
         const SkTextureCompressor::Format fmt = static_cast<SkTextureCompressor::Format>(i);
 
         // Ignore formats for RGBA data, since the decompressed buffer
         // won't match the size and contents of the original.
         if (!decompresses_a8(fmt) || !compresses_a8(fmt)) {
             continue;
         }
 
         SkAutoDataUnref data(SkTextureCompressor::CompressBitmapToFormat(bitmap, fmt));
-        REPORTER_ASSERT(reporter, NULL != data);
+        REPORTER_ASSERT(reporter, data);
         if (NULL == data) {
             continue;
         }
 
         bool decompResult =
             SkTextureCompressor::DecompressBufferFromFormat(
                 decompBuffer, kWidth,
                 data->bytes(),
                 kWidth, kHeight, fmt);
         REPORTER_ASSERT(reporter, decompResult);
 
         SkAutoLockPixels alp(bitmap);
         uint8_t* pixels = reinterpret_cast<uint8_t*>(bitmap.getPixels());
-        REPORTER_ASSERT(reporter, NULL != pixels);
+        REPORTER_ASSERT(reporter, pixels);
         if (NULL == pixels) {
             continue;
         }
 
         for (int y = 0; y < kHeight; ++y) {
             for (int x = 0; x < kWidth; ++x) {
                 bool ok = pixels[y*bitmap.rowBytes() + x] == decompBuffer[y*kWidth + x];
                 REPORTER_ASSERT(reporter, ok);
             }
         }
@@ skipping 25 matching lines @@
     REPORTER_ASSERT(reporter, kWidth % latcDimX == 0);
     REPORTER_ASSERT(reporter, kHeight % latcDimY == 0);
     const size_t kSizeToBe =
         SkTextureCompressor::GetCompressedDataSize(kLATCFormat, kWidth, kHeight);
     REPORTER_ASSERT(reporter, kSizeToBe == ((kWidth*kHeight*kLATCEncodedBlockSize)/16));
     REPORTER_ASSERT(reporter, (kSizeToBe % kLATCEncodedBlockSize) == 0);
 
     for (int lum = 0; lum < 256; ++lum) {
         bitmap.lockPixels();
         uint8_t* pixels = reinterpret_cast<uint8_t*>(bitmap.getPixels());
-        REPORTER_ASSERT(reporter, NULL != pixels);
+        REPORTER_ASSERT(reporter, pixels);
         if (NULL == pixels) {
             bitmap.unlockPixels();
             continue;
         }
 
         for (int i = 0; i < kWidth*kHeight; ++i) {
             pixels[i] = lum;
         }
         bitmap.unlockPixels();
 
         SkAutoDataUnref latcData(
             SkTextureCompressor::CompressBitmapToFormat(bitmap, kLATCFormat));
-        REPORTER_ASSERT(reporter, NULL != latcData);
+        REPORTER_ASSERT(reporter, latcData);
         if (NULL == latcData) {
             continue;
         }
 
         REPORTER_ASSERT(reporter, kSizeToBe == latcData->size());
 
         // Make sure that it all matches a given block encoding. Since we have
         // COMPRESS_LATC_FAST defined in SkTextureCompressor_LATC.cpp, we are using
         // an approximation scheme that optimizes for speed against coverage maps.
         // That means that each palette in the encoded block is exactly the same,
         // and that the three bits saved per pixel are computed from the top three
         // bits of the luminance value.
         const uint64_t kIndexEncodingMap[8] = { 1, 7, 6, 5, 4, 3, 2, 0 };
         const uint64_t kIndex = kIndexEncodingMap[lum >> 5];
         const uint64_t kConstColorEncoding =
             SkEndian_SwapLE64(
                 255 |
                 (kIndex << 16) | (kIndex << 19) | (kIndex << 22) | (kIndex << 25) |
                 (kIndex << 28) | (kIndex << 31) | (kIndex << 34) | (kIndex << 37) |
                 (kIndex << 40) | (kIndex << 43) | (kIndex << 46) | (kIndex << 49) |
                 (kIndex << 52) | (kIndex << 55) | (kIndex << 58) | (kIndex << 61));
 
         const uint64_t* blockPtr = reinterpret_cast<const uint64_t*>(latcData->data());
         for (size_t i = 0; i < (kSizeToBe/8); ++i) {
             REPORTER_ASSERT(reporter, blockPtr[i] == kConstColorEncoding);
         }
     }
 }