## 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.     for (int i = 0; i < 5; i++)
            if (i == 4) {
                body;
            }

57.     for ()
            while () {
                body;
            }

58.     if (a)
            if (b) {
                body;
            }

59.     while (a)
            for (b)
                if (c) {
                    body;
                }

60.     else

61.     public:
            int x;

62.     public:

63.     private:

64.     protected:

65.     case:

66.     namespace r {

67.     namespace r {

68.     namespace {
        class Foo:

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

70.         int q = 4;

71.         void myFunction() {

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

73.     int foo(

74.     switch (x) {

75.     case foo:

76.     case foo: bar;

77.     case foo:
            bar;

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

79.     /***
         *
         */

80.         /***
             *
             */

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

82.     static void namespace_reader() {

83.     class Foo

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

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

86.     class Foo :
            public A,

87.     class Foo:

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

89.     class Foo :
            public TemplateClass<Params>

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

91.     class Foo : public A,

92.     class Foo : public A,
                    public B {

93.     class Foo : public A,
                    public B,

94.     class Foo : public A,
                    public B {

        };

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

96.         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)
            {

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

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

99.     foo( int a,

100.     class Foo : public A

101.     [1, 2, 3,

102.     [[[1, 2, 3,

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

104.     []() noexcept {

105.         SomeBigFunction(
                     a
             );

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

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

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

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

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

111.     void doSomething(
                 ) = 0;

112.     try {

113.     try

114.     try {
             try {

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

116.     try {
         } catch(Exception& e)

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

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

119.     x = 1
             + 2;

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

121.     else if (bar)
             baz;

122.     if () {
             ;
         }
         else {

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

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

125.     while (foo ||

126.     enum Foo
         {
             VALUE_1 = 1,

127.     using namespace Rcpp;
         static

128.     using namespace Rcpp;
         static inline

129.     static

130.     static inline

131.     __attribute__((noreturn))

132.     template <typename ClockDuration>
         cpp11::writable::strings