text: /*
   *
   *    Copyright (c) 2016-2018 Nest Labs, Inc.
   *    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
   *
   *        http://www.apache.org/licenses/LICENSE-2.0
   *
   *    Unless required by applicable law or agreed to in writing, software
   *    distributed under the License is distributed on an "AS IS" BASIS,
   *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   *    See the License for the specific language governing permissions and
   *    limitations under the License.
   */
  #include <stdbool.h>
  #include <stdint.h>
  
  // Positive tests: these should generate a violation
  
  // Arrays
  
  // Missing space around opening brace
  
  static const uint8_t sOctets_1[] = {0x01, 0x02 };
  static const uint8_t sOctets_2[] ={0x01, 0x02 };
  static const uint8_t sOctets_3[] ={ 0x01, 0x02 };
  static const uint8_t sOctets_4[] =	{0x01, 0x02	};
  static const uint8_t sOctets_5[] ={0x01, 0x02	};
  static const uint8_t sOctets_6[] ={	0x01, 0x02	};
  
  // Missing space around closing brace
  
  static const uint8_t sOctets_7[] = { 0x01, 0x02};
  static const uint8_t sOctets_8[] =	{	0x01, 0x02};
  
  // Classes
  
  class class_1 {};
  
  class class_2{ };
  
  class class_3{
  };
  
  // Structures
  
  struct struct_1 {};
  
  struct struct_2{ };
  
  struct struct_3{
  };
  
  // Enumerations
  
  enum enum_1 {};
  
  enum enum_2{ };
  
  enum enum_3{
  };
  
  // Namespaces
  
  namespace namespace_1{};
  
  namespace namespace_1{
  };
  
  namespace namespace_1{namespace namespace_2{};};
  
  namespace namespace_1{
  
  namespace namespace_2{};
  };
  
  // Functions / Methods
  
  static int test_func_1(void){return 0; }
  static int test_func_2(void){ return 0;}
  static inline bool test_func_3(void){
      return false; }
  static inline bool test_func_4(void) {
      return false;}
  static inline void test_func_5(void)
  {int a;
      return;
  }
  
  // Nested Initializers
  
  struct test_struct_5 {
      int m_a;
      bool m_b;
  };
  
  struct test_struct_6 {
      struct test_struct_5 m_a;
      bool m_b;
  };
  
  static const struct test_struct_6 sTestStruct6[] =
      {{{ 0, true }, true }, {{ 1, false}, true }};
  
  // Control Structures
  
  static void test_control_structures(void)
  {
      int a = 0;
      int i = 0;
  
      if (true){a = a + 1;}
  
      if (false){
          a = a - 1;
      }
  
      if (a == 0) {
          a = a + 1;
      }else{
          a = a - 1;}
  
      if (a == 1) {
          a = a * 2;
      }else if (a == 2){
          a = a / 2;
      }
  
      while (a > 0){
          a -= 1;}
  
      do{ a += 1; }while (a < 0);
  
      for (i = 0; i < a; i++){
          a--;}
  
      switch (a){case 0: a += 1;}
  
      switch (a){
  
      case 2: a *= 2;
  
      }
  
      switch (a){
  
      case 1: a -= 1;}
          
  }
  
  // Negative tests: these should not generate a violation
  
  // None for now
  