| /* |
| * Copyright 2017 The Bazel Authors. 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. |
| */ |
| package com.google.idea.blaze.cpp.includes; |
| |
| import static com.google.common.truth.Truth.assertThat; |
| |
| import com.google.idea.blaze.cpp.BlazeCppIntegrationTestCase; |
| import com.google.idea.blaze.cpp.includes.IwyuPragmas.ExportPragma; |
| import com.google.idea.blaze.cpp.includes.IwyuPragmas.KeepPragma; |
| import com.google.idea.blaze.cpp.includes.IwyuPragmas.PrivatePragma; |
| import com.jetbrains.cidr.lang.psi.OCFile; |
| import com.jetbrains.cidr.lang.psi.OCIncludeDirective.Delimiters; |
| import org.junit.Test; |
| import org.junit.runner.RunWith; |
| import org.junit.runners.JUnit4; |
| |
| /** Tests for parsing {@link IwyuPragmas}. */ |
| @RunWith(JUnit4.class) |
| public class IwyuPragmasTest extends BlazeCppIntegrationTestCase { |
| |
| @Test |
| public void noPragmas() { |
| OCFile file = |
| createFile( |
| "bar.cc", |
| "#include \"bar.h\"", |
| "", |
| "#include <memory>", |
| "#include <vector>", |
| "", |
| "#include \"f/foo1.h\"", |
| "#include \"f/foo2.h\"", |
| "#include \"f/foo3.h\" // blah", |
| "", |
| "void bar() {}"); |
| IwyuPragmas pragmas = IwyuPragmas.parse(file); |
| assertThat(pragmas.privatePragma.isPresent()).isFalse(); |
| assertThat(pragmas.keeps).isEmpty(); |
| assertThat(pragmas.exports).isEmpty(); |
| assertThat(pragmas.associatedHeader.isPresent()).isFalse(); |
| } |
| |
| @Test |
| public void incompletePath_parse() { |
| OCFile file = createFile("bar.cc", "#include <memory>", "#include <vecto"); |
| IwyuPragmas pragmas = IwyuPragmas.parse(file); |
| assertThat(pragmas.keeps).isEmpty(); |
| } |
| |
| @Test |
| public void noPathYet_parse() { |
| OCFile file = createFile("bar.cc", "#include <memory>", "#include "); |
| IwyuPragmas pragmas = IwyuPragmas.parse(file); |
| assertThat(pragmas.keeps).isEmpty(); |
| } |
| |
| @Test |
| public void lineComment_parseKeep() { |
| OCFile file = |
| createFile( |
| "bar.cc", |
| "#include \"bar.h\"", |
| "", |
| "#include <memory>", |
| "#include <vector> // IWYU pragma: keep", |
| "", |
| "#include \"f/foo1.h\" // IWYU pragma: keep", |
| "#include \"f/foo2.h\"", |
| "#include \"f/foo3.h\" // IWYU pragma: keep ", |
| "", |
| "void bar() {}"); |
| IwyuPragmas pragmas = IwyuPragmas.parse(file); |
| assertThat(pragmas.keeps) |
| .containsExactly( |
| KeepPragma.create(IncludePath.create("vector", Delimiters.ANGLE_BRACKETS)), |
| KeepPragma.create(IncludePath.create("f/foo1.h", Delimiters.QUOTES)), |
| KeepPragma.create(IncludePath.create("f/foo3.h", Delimiters.QUOTES))); |
| } |
| |
| @Test |
| public void blockComment_parseKeep() { |
| OCFile file = |
| createFile( |
| "bar.cc", |
| "#include \"bar.h\"", |
| "", |
| "#include <memory>", |
| "#include <vector> /* IWYU pragma: keep */", |
| "", |
| "#include \"f/foo1.h\" /* IWYU pragma: keep */", |
| "#include \"f/foo2.h\"", |
| "#include \"f/foo3.h\" /* IWYU pragma: keep */", |
| "", |
| "void bar() {}"); |
| IwyuPragmas pragmas = IwyuPragmas.parse(file); |
| assertThat(pragmas.keeps) |
| .containsExactly( |
| KeepPragma.create(IncludePath.create("vector", Delimiters.ANGLE_BRACKETS)), |
| KeepPragma.create(IncludePath.create("f/foo1.h", Delimiters.QUOTES)), |
| KeepPragma.create(IncludePath.create("f/foo3.h", Delimiters.QUOTES))); |
| } |
| |
| @Test |
| public void lineCommentIncludeGuardPrefixes_parseKeep() { |
| OCFile file = |
| createFile( |
| "bar.h", |
| "#ifndef BAR_H_", |
| "#define BAR_H_", |
| "#include <memory>", |
| "#include <vector> // IWYU pragma: keep", |
| "", |
| "#include \"f/foo1.h\" // IWYU pragma: keep", |
| "#include \"f/foo2.h\"", |
| "#include \"f/foo3.h\" // IWYU pragma: keep ", |
| "", |
| "void bar();", |
| "#endif"); |
| IwyuPragmas pragmas = IwyuPragmas.parse(file); |
| assertThat(pragmas.keeps) |
| .containsExactly( |
| KeepPragma.create(IncludePath.create("vector", Delimiters.ANGLE_BRACKETS)), |
| KeepPragma.create(IncludePath.create("f/foo1.h", Delimiters.QUOTES)), |
| KeepPragma.create(IncludePath.create("f/foo3.h", Delimiters.QUOTES))); |
| } |
| |
| @Test |
| public void incompletePragma_parseKeep() { |
| OCFile file = |
| createFile( |
| "bar.cc", |
| "#include \"f/foo1.h\" // IWYU pragma: kee", |
| "#include \"f/foo2.h\" // IWYU pragma: keep"); |
| IwyuPragmas pragmas = IwyuPragmas.parse(file); |
| assertThat(pragmas.keeps) |
| .containsExactly(KeepPragma.create(IncludePath.create("f/foo2.h", Delimiters.QUOTES))); |
| } |
| |
| @Test |
| public void hasSuffixSoNoMatch_parseKeep() { |
| OCFile file = |
| createFile( |
| "bar.cc", |
| "#include \"f/foo1.h\" // IWYU pragma: keepaway", |
| "#include \"f/foo2.h\" // IWYU pragma: keep"); |
| IwyuPragmas pragmas = IwyuPragmas.parse(file); |
| assertThat(pragmas.keeps) |
| .containsExactly(KeepPragma.create(IncludePath.create("f/foo2.h", Delimiters.QUOTES))); |
| } |
| |
| @Test |
| public void insideNamespace_parseKeep() { |
| OCFile file = |
| createFile( |
| "bar.cc", |
| "#include \"f/foo1.h\" // IWYU pragma: keep", |
| "#include \"f/foo2.h\"", |
| "namespace change_namespace {", |
| "#include \"f/foo3.h\" // IWYU pragma: keep", |
| "}", |
| "class C {", |
| "#include \"f/foo4.h\" // IWYU pragma: keep", |
| "};"); |
| IwyuPragmas pragmas = IwyuPragmas.parse(file); |
| assertThat(pragmas.keeps) |
| .containsExactly( |
| KeepPragma.create(IncludePath.create("f/foo1.h", Delimiters.QUOTES)), |
| KeepPragma.create(IncludePath.create("f/foo3.h", Delimiters.QUOTES)), |
| KeepPragma.create(IncludePath.create("f/foo4.h", Delimiters.QUOTES))); |
| } |
| |
| @Test |
| public void duplicate_parseKeep() { |
| // Probably need to disambiguate the PSI nodes somewhere (last one shouldn't be kept?) |
| OCFile file = |
| createFile( |
| "bar.cc", |
| "#include \"f/foo1.h\" // IWYU pragma: keep", |
| "#include \"f/foo1.h\" // IWYU pragma: keep", |
| "#include \"f/foo1.h\""); |
| IwyuPragmas pragmas = IwyuPragmas.parse(file); |
| assertThat(pragmas.keeps) |
| .containsExactly(KeepPragma.create(IncludePath.create("f/foo1.h", Delimiters.QUOTES))); |
| } |
| |
| @Test |
| public void parseExport() { |
| OCFile file = |
| createFile( |
| "public/foo.h", |
| "/** Stuff */", |
| "#include <private/memory> // IWYU pragma: export", |
| "#include <vector>", |
| "", |
| "#include \"private/foo1.h\" // IWYU pragma: export", |
| "#include \"private/foo2.h\"", |
| "#include \"private/foo3.h\" // IWYU pragma: export", |
| "", |
| "void doFoo(Foo* f);"); |
| IwyuPragmas pragmas = IwyuPragmas.parse(file); |
| assertThat(pragmas.exports) |
| .containsExactly( |
| ExportPragma.create(IncludePath.create("private/memory", Delimiters.ANGLE_BRACKETS)), |
| ExportPragma.create(IncludePath.create("private/foo1.h", Delimiters.QUOTES)), |
| ExportPragma.create(IncludePath.create("private/foo3.h", Delimiters.QUOTES))); |
| } |
| |
| @Test |
| public void singeRange_parseExportBeginEnd() { |
| OCFile file = |
| createFile( |
| "public/foo.h", |
| "/** Stuff */", |
| "// IWYU pragma: begin_exports", |
| "#include <private/memory>", |
| "#include \"private/foo1.h\"", |
| "#include \"private/foo2.h\"", |
| "// IWYU pragma: end_exports", |
| "#include \"private/foo3.h\""); |
| IwyuPragmas pragmas = IwyuPragmas.parse(file); |
| assertThat(pragmas.exports) |
| .containsExactly( |
| ExportPragma.create(IncludePath.create("private/memory", Delimiters.ANGLE_BRACKETS)), |
| ExportPragma.create(IncludePath.create("private/foo1.h", Delimiters.QUOTES)), |
| ExportPragma.create(IncludePath.create("private/foo2.h", Delimiters.QUOTES))); |
| } |
| |
| @Test |
| public void multipleRanges_parseExportBeginEnd() { |
| OCFile file = |
| createFile( |
| "public/foo.h", |
| "/** Stuff */", |
| "// IWYU pragma: begin_exports", |
| "#include <private/memory>", |
| "#include \"private/foo1.h\"", |
| "#include \"private/foo2.h\"", |
| "// IWYU pragma: end_exports", |
| "#include \"private/foo3.h\"", |
| "#include \"private/foo4.h\"", |
| " // IWYU pragma: begin_exports", |
| "#include \"private/foo5.h\"", |
| " // IWYU pragma: end_exports", |
| "#include \"private/foo6.h\"", |
| "", |
| "void doFoo(Foo& f);"); |
| IwyuPragmas pragmas = IwyuPragmas.parse(file); |
| assertThat(pragmas.exports) |
| .containsExactly( |
| ExportPragma.create(IncludePath.create("private/memory", Delimiters.ANGLE_BRACKETS)), |
| ExportPragma.create(IncludePath.create("private/foo1.h", Delimiters.QUOTES)), |
| ExportPragma.create(IncludePath.create("private/foo2.h", Delimiters.QUOTES)), |
| ExportPragma.create(IncludePath.create("private/foo5.h", Delimiters.QUOTES))); |
| } |
| |
| @Test |
| public void exportRangePlusInlineKeep() { |
| // Probably need to disambiguate the PSI nodes somewhere (last one shouldn't be kept?) |
| OCFile file = |
| createFile( |
| "public/foo.h", |
| "// IWYU pragma: begin_exports", |
| "#include <memory>", |
| "#include \"private/foo1.h\" // IWYU pragma: keep", |
| "#include \"private/foo2.h\" // IWYU pragma: keep", |
| "#include \"private/foo3.h\"", |
| "// IWYU pragma: end_exports", |
| "#include \"private/foo4.h\"", |
| "", |
| "void doFoo(Foo& f);"); |
| IwyuPragmas pragmas = IwyuPragmas.parse(file); |
| assertThat(pragmas.keeps) |
| .containsExactly( |
| KeepPragma.create(IncludePath.create("private/foo1.h", Delimiters.QUOTES)), |
| KeepPragma.create(IncludePath.create("private/foo2.h", Delimiters.QUOTES))); |
| assertThat(pragmas.exports) |
| .containsExactly( |
| ExportPragma.create(IncludePath.create("memory", Delimiters.ANGLE_BRACKETS)), |
| ExportPragma.create(IncludePath.create("private/foo1.h", Delimiters.QUOTES)), |
| ExportPragma.create(IncludePath.create("private/foo2.h", Delimiters.QUOTES)), |
| ExportPragma.create(IncludePath.create("private/foo3.h", Delimiters.QUOTES))); |
| } |
| |
| @Test |
| public void parsePrivate() { |
| OCFile file = |
| createFile( |
| "private.h", "// Stuff", "// IWYU pragma: private", "#include \"private_details.h\""); |
| IwyuPragmas pragmas = IwyuPragmas.parse(file); |
| assertThat(pragmas.privatePragma.isPresent()).isTrue(); |
| PrivatePragma privatePragma = pragmas.privatePragma.get(); |
| assertThat(privatePragma.includeOther.isPresent()).isFalse(); |
| } |
| |
| @Test |
| public void incomplete_parsePrivate() { |
| OCFile file = |
| createFile( |
| "private.h", "// Stuff", "// IWYU pragma: privat", "#include \"private_details.h\""); |
| IwyuPragmas pragmas = IwyuPragmas.parse(file); |
| assertThat(pragmas.privatePragma.isPresent()).isFalse(); |
| } |
| |
| @Test |
| public void parsePrivateIncludeOther() { |
| OCFile file = |
| createFile( |
| "private.h", |
| "// IWYU pragma: private, include \"f/public.h\"", |
| "#include \"private_details.h\""); |
| IwyuPragmas pragmas = IwyuPragmas.parse(file); |
| assertThat(pragmas.privatePragma.isPresent()).isTrue(); |
| PrivatePragma privatePragma = pragmas.privatePragma.get(); |
| assertThat(privatePragma.includeOther.isPresent()).isTrue(); |
| assertThat(privatePragma.includeOther.get()) |
| .isEqualTo(IncludePath.create("f/public.h", Delimiters.QUOTES)); |
| } |
| |
| @Test |
| public void withWhiteSpace_parsePrivateIncludeOther() { |
| OCFile file = |
| createFile( |
| "private.h", |
| "// IWYU pragma:private,include\"f/public.h\" ", |
| "#include \"private_details.h\""); |
| IwyuPragmas pragmas = IwyuPragmas.parse(file); |
| assertThat(pragmas.privatePragma.isPresent()).isTrue(); |
| PrivatePragma privatePragma = pragmas.privatePragma.get(); |
| assertThat(privatePragma.includeOther.isPresent()).isTrue(); |
| assertThat(privatePragma.includeOther.get()) |
| .isEqualTo(IncludePath.create("f/public.h", Delimiters.QUOTES)); |
| } |
| |
| @Test |
| public void parsePrivateIncludeOtherAngle() { |
| OCFile file = |
| createFile( |
| "private.h", |
| "// IWYU pragma: private, include <f/public.h>", |
| "#include \"private_details.h\""); |
| IwyuPragmas pragmas = IwyuPragmas.parse(file); |
| assertThat(pragmas.privatePragma.isPresent()).isTrue(); |
| PrivatePragma privatePragma = pragmas.privatePragma.get(); |
| assertThat(privatePragma.includeOther.isPresent()).isTrue(); |
| assertThat(privatePragma.includeOther.get()) |
| .isEqualTo(IncludePath.create("f/public.h", Delimiters.ANGLE_BRACKETS)); |
| } |
| |
| @Test |
| public void parsePrivateIncludeOtherNoQuotes() { |
| OCFile file = |
| createFile( |
| "private.h", |
| "// IWYU pragma: private, include f/public.h", |
| "#include \"private_details.h\""); |
| IwyuPragmas pragmas = IwyuPragmas.parse(file); |
| assertThat(pragmas.privatePragma.isPresent()).isTrue(); |
| PrivatePragma privatePragma = pragmas.privatePragma.get(); |
| assertThat(privatePragma.includeOther.isPresent()).isTrue(); |
| assertThat(privatePragma.includeOther.get()) |
| .isEqualTo(IncludePath.create("f/public.h", Delimiters.NONE)); |
| } |
| |
| @Test |
| public void hasMultiple_parsePrivate() { |
| // We shouldn't have multiple private pragmas, but we just take the last one. |
| // An alternative might be to take the most descriptive one (when there is a unique |
| // most descriptive one). |
| OCFile file = |
| createFile( |
| "private.h", |
| "// Stuff", |
| "// IWYU pragma: private", |
| "// IWYU pragma: private, include \"public.h\"", |
| "#include \"private_details.h\""); |
| IwyuPragmas pragmas = IwyuPragmas.parse(file); |
| assertThat(pragmas.privatePragma.isPresent()).isTrue(); |
| PrivatePragma privatePragma = pragmas.privatePragma.get(); |
| assertThat(privatePragma.includeOther.isPresent()).isTrue(); |
| assertThat(privatePragma.includeOther.get()) |
| .isEqualTo(IncludePath.create("public.h", Delimiters.QUOTES)); |
| } |
| |
| @Test |
| public void hasMultipleOtherOrder_parsePrivate() { |
| // Like hasMultiple_parsePrivate, but with order swapped |
| OCFile file = |
| createFile( |
| "private.h", |
| "// Stuff", |
| "// IWYU pragma: private, include \"public.h\"", |
| "// IWYU pragma: private", |
| "#include \"private_details.h\""); |
| IwyuPragmas pragmas = IwyuPragmas.parse(file); |
| assertThat(pragmas.privatePragma.isPresent()).isTrue(); |
| PrivatePragma privatePragma = pragmas.privatePragma.get(); |
| assertThat(privatePragma.includeOther.isPresent()).isFalse(); |
| } |
| |
| @Test |
| public void sortOfCommentViaIfdef_parsePrivate() { |
| OCFile file = |
| createFile("bar.cc", "#include <memory>", "#if 0", "IWYU pragma: private", "#endif"); |
| IwyuPragmas pragmas = IwyuPragmas.parse(file); |
| // We don't really support this, but #ifdef'ed out things may be parsed as PsiComment, |
| // so at least make sure we don't assert. Answer could go either way. |
| assertThat(pragmas.privatePragma.isPresent()).isTrue(); |
| PrivatePragma privatePragma = pragmas.privatePragma.get(); |
| assertThat(privatePragma.includeOther.isPresent()).isFalse(); |
| } |
| |
| @Test |
| public void parseAssociated() { |
| OCFile file = |
| createFile( |
| "implementation.cc", |
| "#include \"some/interface.h\" // IWYU pragma: associated", |
| "", |
| "#include \"other_stuff.h\""); |
| IwyuPragmas pragmas = IwyuPragmas.parse(file); |
| assertThat(pragmas.associatedHeader.isPresent()).isTrue(); |
| assertThat(pragmas.associatedHeader.get()) |
| .isEqualTo(IncludePath.create("some/interface.h", Delimiters.QUOTES)); |
| } |
| |
| @Test |
| public void parseAssociatedAngle() { |
| OCFile file = |
| createFile( |
| "implementation.cc", |
| "#include <some/interface.h> // IWYU pragma: associated", |
| "", |
| "#include \"other_stuff.h\""); |
| IwyuPragmas pragmas = IwyuPragmas.parse(file); |
| assertThat(pragmas.associatedHeader.isPresent()).isTrue(); |
| assertThat(pragmas.associatedHeader.get()) |
| .isEqualTo(IncludePath.create("some/interface.h", Delimiters.ANGLE_BRACKETS)); |
| } |
| } |
