## Interactive Tester

## Configure Editor

## Automated Tests

Passed: , Failed:

1.     #define foo

2.     #ifndef foo

3.     class foo;

4.     class foo    {

5.     struct  bar{

6.     template <>

7.     template <
       >

8.     template <
           template <

9.     template <int RTYPE,

10.     template <int RTYPE,
                  template <class> class StoragePolicy>

11.     template <int RTYPE, template <class> class StoragePolicy = PreserveStorage >
        class Vector :

12.                 /*
                    */
        struct some_tag_struct_with_block_comment_above{} ;

13.     template <
            int RTYPE
        > class
        foo;

14.     template <
            int RTYPE,

15.         inline void foo() { return foo_; }

16.     void SomeFunction(

17.     return List::create(
            _["x"] = 1,

18.     a +
            b;

19.     int foo = bar,

20.     int foo =
            bar();

21.     foo::bar
            // some weird comment
            (arguments on own line)

22.     class Foo{};
        class Foo{};

23.     foo
            ()
            : a_(a)

24.     foo
            ()
            : a_(a)
        {

25.     foo
            ()
            : a_(a) {

26.     foo
            () :
            a_(a)

27.     int foo
            (int a) {

28.     {

29.     {
            bar;

30.     struct bar{};

31.     class foo :
          A,

32.     class foo : A,

33.     class foo : bar<T> {

34.     template <typename T>

35.     class foo : public bar::baz {

36.         class foo

            :

        public ::bar::baz,
        public ::bat::man {

37.     class foo:
          public A {

38.     if (1 == 2) {

39.     if (1 >
            2)

40.     if (1 >
                      2)
            return true;

41.     if (()
            a())

42.     if (1 == 2) { return 1 }

43.     if (1 == 2)

44.     if (a)
            if (b)

45.     else if (bar)

46.     while (a)
            while (b)
                c++;

47.         for(a; b;
                c)
                ;

48.     #include <foo>

49.     for ( something that could kindly be vertically aligned;

50.     for ( tricky to
                  vertically align;

51.     for () {
            foo;

52.     else

53.     for ()
            while ()

54.     for ()
            while ()
                ;

55.     for () {
            x > 0;

56.     else

57.     public:
            int x;

58.     public:

59.     private:

60.     protected:

61.     case:

62.     namespace r {

63.     namespace r {

64.     namespace {
        class Foo:

65.     int z = 4;
        int x = 1 +

66.         int q = 4;

67.         void myFunction() {

68.         void myFunction() { // This function will be amazing

69.     int foo(

70.     switch (x) {

71.     case foo:

72.     case foo: bar;

73.     case foo:
            bar;

74.     std::find_if(x.begin(), x.end(), [](int x) {

75.     /***
         *
         */

76.         /***
             *
             */

77.     std::string msg =
                "A multi-line message"

78.     static void namespace_reader() {

79.     class Foo

80.     class Foo {
        public:
            struct Entry {
                std::string file;

81.     Foo(const int a,
            const int b)
            : a_(a),
              b_(b),
              c_(c) {

82.     class Foo :
            public A,

83.     class Foo:

84.     class Foo :
            public A,
            public B,
            public C {

85.     class Foo :
            public TemplateClass<Params>

86.     class Foo :
            public TemplateClass<Many, Template, Parameters>

87.     class Foo : public A,

88.     class Foo : public A,
                    public B {

89.     class Foo : public A,
                    public B,

90.     class Foo : public A,
                    public B {

        };

91.     Foo(int a, int b):
            a_(a),

92.         Foo(const int a, int b, int c,
                const int d, int e, int f)
                : a_(a), b_(b), c_(c),
                  d_(d), e_(e), f_(f)
            {

93.     std::find_if(x.begin(),

94.     std::find_if(x.begin(),
                     x.end(),
                     [](x) {

95.     foo( int a,

96.     class Foo : public A

97.     [1, 2, 3,

98.     [[[1, 2, 3,

99.     [[[1, 2, 3,
           4, 5, 6,
           7, 8, 9],

100.     []() noexcept {

101.         SomeBigFunction(
                     a
             );

102.     int foo(const int a,
                 const int b,
                 const unsigned int c) const {

103.     int foo(const unsigned int a,
                 const unsigned int b,
                 const unsigned int c) const noexcept
             : a_(a),
               b_(b),
               c_(c)

104.     int foo(const unsigned int a,
                 const unsigned int b,
                 const unsigned int c) const noexcept {

105.     int foo(const unsigned int a,
                 const unsigned int b,
                 const unsigned int c) const noexcept

106.     int foo(const unsigned int a,
                 const unsigned int b,
                 const unsigned int c) noexcept :

107.     void doSomething(
                 ) = 0;

108.     try {

109.     try

110.     try {
             try {

111.     try {
         } catch(Exception& e) {

112.     try {
         } catch(Exception& e)

113.     std::string msg =
             "This is a"
             "long message";

114.     return someStatementReturningTrue() ?
             truthyValue() :
             falsyValue();

115.     x = 1
             + 2;

116.     foo(bar,
             "// annoying comment with \"in-line quotes\"", "with // another string",
             baz);

117.     else if (bar)
             baz;

118.     if () {
             ;
         }
         else {

119.     Param::Param(const std::string& paramText)

120.     class Foo {
         public:
             int foo(int a,
                     int b)

121.     while (foo ||

122.     enum Foo
         {
             VALUE_1 = 1,