Fix Astyle failures

Author: Seppo Takalo

.astyleignore

@@ -31,3 +31,4 @@
 ^TESTS/mbed_hal/trng/pithy
 ^TESTS/mbed_hal/trng/pithy
 ^tools
+^UNITTESTS

UNITTESTS/features/storage/blockdevice/HeapBlockDevice/test.cpp

@@ -51,7 +51,7 @@ TEST_F(HeapBlockDeviceTest, get_type)
 
 TEST_F(HeapBlockDeviceTest, erase_program_read)
 {
-    uint8_t *block = new uint8_t[BLOCK_SIZE]{0xaa,0xbb,0xcc};
+    uint8_t *block = new uint8_t[BLOCK_SIZE] {0xaa,0xbb,0xcc};
     uint8_t *buf = new uint8_t[BLOCK_SIZE];
     EXPECT_EQ(bd.erase(0, BLOCK_SIZE),          BD_ERROR_OK);
     EXPECT_EQ(bd.program(block, 0, BLOCK_SIZE), BD_ERROR_OK);
@@ -79,7 +79,7 @@ TEST_F(HeapBlockDeviceTest, over_read)
 
 TEST_F(HeapBlockDeviceTest, over_write)
 {
-    uint8_t *buf = new uint8_t[BLOCK_SIZE]{0xaa,0xbb,0xcc};
+    uint8_t *buf = new uint8_t[BLOCK_SIZE] {0xaa,0xbb,0xcc};
     EXPECT_EQ(bd.program(buf, DEVICE_SIZE, BLOCK_SIZE), BD_ERROR_DEVICE_ERROR);
     delete[] buf;
 }

UNITTESTS/moduletests/storage/blockdevice/SlicingBlockDevice/moduletest.cpp

@@ -12,7 +12,8 @@ class VerifyBorders_HeapBlockDevice : public  mbed::HeapBlockDevice {
     mutable bd_size_t upper_limit;
 
     VerifyBorders_HeapBlockDevice(bd_size_t size)
-        : HeapBlockDevice(size) {
+        : HeapBlockDevice(size)
+    {
         borders_crossed = false;
         lower_limit = 0;
         upper_limit = size;
@@ -21,21 +22,21 @@ class VerifyBorders_HeapBlockDevice : public  mbed::HeapBlockDevice {
     virtual bool is_valid_read(bd_addr_t addr, bd_size_t size) const
     {
         borders_crossed |= addr < lower_limit;
-        borders_crossed |= addr+size > upper_limit;
+        borders_crossed |= addr + size > upper_limit;
         return BlockDevice::is_valid_read(addr, size);
     }
 
     virtual bool is_valid_program(bd_addr_t addr, bd_size_t size) const
     {
         borders_crossed |= addr < lower_limit;
-        borders_crossed |= addr+size > upper_limit;
+        borders_crossed |= addr + size > upper_limit;
         return BlockDevice::is_valid_program(addr, size);
     }
 
     virtual bool is_valid_erase(bd_addr_t addr, bd_size_t size) const
     {
         borders_crossed |= addr < lower_limit;
-        borders_crossed |= addr+size > upper_limit;
+        borders_crossed |= addr + size > upper_limit;
         return BlockDevice::is_valid_erase(addr, size);
     }
 };
@@ -51,7 +52,7 @@ class SlicingBlockModuleTest : public testing::Test {
         magic = new uint8_t[BLOCK_SIZE];
         buf = new uint8_t[BLOCK_SIZE];
         // Generate simple pattern to verify against
-        for (int i=0; i < BLOCK_SIZE; i++) {
+        for (int i = 0; i < BLOCK_SIZE; i++) {
             magic[i] = 0xaa + i;
         }
     }
@@ -77,20 +78,20 @@ TEST_F(SlicingBlockModuleTest, constructor)
 
 TEST_F(SlicingBlockModuleTest, slice_in_middle)
 {
-    uint8_t *program = new uint8_t[BLOCK_SIZE]{0xbb,0xbb,0xbb};
+    uint8_t *program = new uint8_t[BLOCK_SIZE] {0xbb,0xbb,0xbb};
 
     //Write magic value to heap block before and after the space for slice
     bd.program(magic, 0, BLOCK_SIZE);
-    bd.program(magic, BLOCK_SIZE*3, BLOCK_SIZE);
+    bd.program(magic, BLOCK_SIZE * 3, BLOCK_SIZE);
 
-    bd.upper_limit = BLOCK_SIZE*3;
+    bd.upper_limit = BLOCK_SIZE * 3;
     bd.lower_limit = BLOCK_SIZE;
     bd.borders_crossed = false;
 
     //Skip first block, then create sclicing device, with size of 2 blocks
-    mbed::SlicingBlockDevice slice(&bd, BLOCK_SIZE, BLOCK_SIZE*3);
+    mbed::SlicingBlockDevice slice(&bd, BLOCK_SIZE, BLOCK_SIZE * 3);
     EXPECT_EQ(slice.init(), BD_ERROR_OK);
-    EXPECT_EQ(BLOCK_SIZE*2, slice.size());
+    EXPECT_EQ(BLOCK_SIZE * 2, slice.size());
     EXPECT_EQ(bd.borders_crossed, false);
 
     //Program a test value
@@ -101,44 +102,44 @@ TEST_F(SlicingBlockModuleTest, slice_in_middle)
     //Verify that blocks before and after the slicing blocks are not touched
     bd.read(buf, 0, BLOCK_SIZE);
     EXPECT_EQ(0, memcmp(buf, magic, BLOCK_SIZE));
-    bd.read(buf, BLOCK_SIZE*3, BLOCK_SIZE);
+    bd.read(buf, BLOCK_SIZE * 3, BLOCK_SIZE);
     EXPECT_EQ(0, memcmp(buf, magic, BLOCK_SIZE));
 }
 
 TEST_F(SlicingBlockModuleTest, slice_at_the_end)
 {
-    uint8_t *program = new uint8_t[BLOCK_SIZE]{0xbb,0xbb,0xbb};
+    uint8_t *program = new uint8_t[BLOCK_SIZE] {0xbb,0xbb,0xbb};
 
     //Write magic value to heap block before the space for slice
     // our bd is 10*BLOCK_SIZE, so sector 7
-    bd.program(magic, BLOCK_SIZE*7, BLOCK_SIZE);
+    bd.program(magic, BLOCK_SIZE * 7, BLOCK_SIZE);
 
     //Screate sclicing device, with size of 2 blocks
     // Use negative index
     mbed::SlicingBlockDevice slice(&bd, -BLOCK_SIZE*2);
     EXPECT_EQ(slice.init(), BD_ERROR_OK);
-    EXPECT_EQ(BLOCK_SIZE*2, slice.size());
+    EXPECT_EQ(BLOCK_SIZE * 2, slice.size());
 
     //Program a test value
     EXPECT_EQ(slice.program(program, 0, BLOCK_SIZE), BD_ERROR_OK);
     EXPECT_EQ(slice.program(program, BLOCK_SIZE, BLOCK_SIZE), BD_ERROR_OK);
 
     //Verify that blocks before and after the slicing blocks are not touched
-    bd.read(buf, BLOCK_SIZE*7, BLOCK_SIZE);
+    bd.read(buf, BLOCK_SIZE * 7, BLOCK_SIZE);
     EXPECT_EQ(0, memcmp(buf, magic, BLOCK_SIZE));
 }
 
 TEST_F(SlicingBlockModuleTest, over_write)
 {
-    uint8_t *program = new uint8_t[BLOCK_SIZE]{0xbb,0xbb,0xbb};
+    uint8_t *program = new uint8_t[BLOCK_SIZE] {0xbb,0xbb,0xbb};
 
     //Screate sclicing device, with size of 2 blocks
-    mbed::SlicingBlockDevice slice(&bd, BLOCK_SIZE, BLOCK_SIZE*3);
+    mbed::SlicingBlockDevice slice(&bd, BLOCK_SIZE, BLOCK_SIZE * 3);
     EXPECT_EQ(slice.init(), BD_ERROR_OK);
 
     EXPECT_EQ(slice.program(program, 0, BLOCK_SIZE), BD_ERROR_OK);
     EXPECT_EQ(slice.program(program, BLOCK_SIZE, BLOCK_SIZE), BD_ERROR_OK);
     //Program a test value to address that is one pass the device size
-    EXPECT_EQ(slice.program(program, 2*BLOCK_SIZE, BLOCK_SIZE), BD_ERROR_DEVICE_ERROR);
+    EXPECT_EQ(slice.program(program, 2 * BLOCK_SIZE, BLOCK_SIZE), BD_ERROR_DEVICE_ERROR);
 
 }

UNITTESTS/stubs/mbed_atomic_stub.c

@@ -57,33 +57,33 @@ uint32_t core_util_atomic_exchange_u32(volatile uint32_t *ptr, uint32_t desiredV
 
 uint8_t core_util_atomic_incr_u8(volatile uint8_t *valuePtr, uint8_t delta)
 {
-    return *valuePtr+=delta;
+    return *valuePtr += delta;
 }
 
 uint16_t core_util_atomic_incr_u16(volatile uint16_t *valuePtr, uint16_t delta)
 {
-    return *valuePtr+=delta;
+    return *valuePtr += delta;
 }
 
 uint32_t core_util_atomic_incr_u32(volatile uint32_t *valuePtr, uint32_t delta)
 {
-    return *valuePtr+=delta;
+    return *valuePtr += delta;
 }
 
 
 uint8_t core_util_atomic_decr_u8(volatile uint8_t *valuePtr, uint8_t delta)
 {
-    return *valuePtr-=delta;
+    return *valuePtr -= delta;
 }
 
 uint16_t core_util_atomic_decr_u16(volatile uint16_t *valuePtr, uint16_t delta)
 {
-    return *valuePtr-=delta;
+    return *valuePtr -= delta;
 }
 
 uint32_t core_util_atomic_decr_u32(volatile uint32_t *valuePtr, uint32_t delta)
 {
-    return *valuePtr-=delta;
+    return *valuePtr -= delta;
 }
 
 

UNITTESTS/target_h/PinNames.h

@@ -34,9 +34,9 @@ typedef enum {
 } PinName;
 
 typedef enum {
-	PullNone,
-	PullUp,
-	PullDown
+    PullNone,
+    PullUp,
+    PullDown
 } PinMode;
 
 typedef enum {

UNITTESTS/target_h/gpio_object.h

@@ -27,7 +27,7 @@ extern "C" {
 #endif
 
 typedef struct {
-	int unused;
+   int unused;
 } gpio_t;
 
 #ifdef __cplusplus

UNITTESTS/target_h/objects.h

@@ -34,39 +34,39 @@ struct serial_s {
 };
 
 struct dac_s {
-	int unused;
+    int unused;
 };
 
 struct i2c_s {
-	int unused;
+    int unused;
 };
 
 struct qspi_s {
-	int unused;
+    int unused;
 };
 
 struct spi_s {
-	int unused;
+    int unused;
 };
 
 struct analogin_s {
-	int unused;
+    int unused;
 };
 
 struct port_s {
-	int unused;
+    int unused;
 };
 
 struct pwmout_s {
-	int unused;
+    int unused;
 };
 
 struct flash_s {
-	int unused;
+    int unused;
 };
 
 struct can_s {
-	int unused;
+    int unused;
 };
 
 #include "gpio_object.h"